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, 2009, 2010, 2011
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
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
61 (3) ELF section symbols are handled rather sloppily now. This should
62 be cleaned up, and ELF section symbols reconciled with BFD section
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
72 #include "libiberty.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_core_file_pid NAME(bfd_elf,core_file_pid)
91 #define elf_object_p NAME(bfd_elf,object_p)
92 #define elf_core_file_p NAME(bfd_elf,core_file_p)
93 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
94 #define elf_get_dynamic_symtab_upper_bound \
95 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
96 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
97 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
98 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
99 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
100 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
101 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
102 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
103 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
104 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
105 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
106 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
107 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
108 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
109 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
110 #define elf_canonicalize_dynamic_symtab \
111 NAME(bfd_elf,canonicalize_dynamic_symtab)
112 #define elf_get_synthetic_symtab \
113 NAME(bfd_elf,get_synthetic_symtab)
114 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
115 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
116 #define elf_get_lineno NAME(bfd_elf,get_lineno)
117 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
118 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
119 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
120 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
121 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
122 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
123 #define elf_find_section NAME(bfd_elf,find_section)
124 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
125 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
126 #define elf_checksum_contents NAME(bfd_elf,checksum_contents)
127 #define elf_write_relocs NAME(bfd_elf,write_relocs)
128 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
131 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
132 #define ELF_R_SYM(X) ELF64_R_SYM(X)
133 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
134 #define ELFCLASS ELFCLASS64
136 #define LOG_FILE_ALIGN 3
139 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
140 #define ELF_R_SYM(X) ELF32_R_SYM(X)
141 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
142 #define ELFCLASS ELFCLASS32
144 #define LOG_FILE_ALIGN 2
148 static void elf_debug_section (int, Elf_Internal_Shdr *);
151 static void elf_debug_file (Elf_Internal_Ehdr *);
154 /* Structure swapping routines */
156 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
157 can be handled by explicitly specifying 32 bits or "the long type". */
159 #define H_PUT_WORD H_PUT_64
160 #define H_PUT_SIGNED_WORD H_PUT_S64
161 #define H_GET_WORD H_GET_64
162 #define H_GET_SIGNED_WORD H_GET_S64
165 #define H_PUT_WORD H_PUT_32
166 #define H_PUT_SIGNED_WORD H_PUT_S32
167 #define H_GET_WORD H_GET_32
168 #define H_GET_SIGNED_WORD H_GET_S32
171 /* Translate an ELF symbol in external format into an ELF symbol in internal
175 elf_swap_symbol_in (bfd *abfd,
178 Elf_Internal_Sym *dst)
180 const Elf_External_Sym *src = (const Elf_External_Sym *) psrc;
181 const Elf_External_Sym_Shndx *shndx = (const Elf_External_Sym_Shndx *) pshn;
182 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
184 dst->st_name = H_GET_32 (abfd, src->st_name);
186 dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
188 dst->st_value = H_GET_WORD (abfd, src->st_value);
189 dst->st_size = H_GET_WORD (abfd, src->st_size);
190 dst->st_info = H_GET_8 (abfd, src->st_info);
191 dst->st_other = H_GET_8 (abfd, src->st_other);
192 dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
193 if (dst->st_shndx == (SHN_XINDEX & 0xffff))
197 dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
199 else if (dst->st_shndx >= (SHN_LORESERVE & 0xffff))
200 dst->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
201 dst->st_target_internal = 0;
205 /* Translate an ELF symbol in internal format into an ELF symbol in external
209 elf_swap_symbol_out (bfd *abfd,
210 const Elf_Internal_Sym *src,
215 Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
216 H_PUT_32 (abfd, src->st_name, dst->st_name);
217 H_PUT_WORD (abfd, src->st_value, dst->st_value);
218 H_PUT_WORD (abfd, src->st_size, dst->st_size);
219 H_PUT_8 (abfd, src->st_info, dst->st_info);
220 H_PUT_8 (abfd, src->st_other, dst->st_other);
222 if (tmp >= (SHN_LORESERVE & 0xffff) && tmp < SHN_LORESERVE)
226 H_PUT_32 (abfd, tmp, shndx);
227 tmp = SHN_XINDEX & 0xffff;
229 H_PUT_16 (abfd, tmp, dst->st_shndx);
232 /* Translate an ELF file header in external format into an ELF file header in
236 elf_swap_ehdr_in (bfd *abfd,
237 const Elf_External_Ehdr *src,
238 Elf_Internal_Ehdr *dst)
240 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
241 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
242 dst->e_type = H_GET_16 (abfd, src->e_type);
243 dst->e_machine = H_GET_16 (abfd, src->e_machine);
244 dst->e_version = H_GET_32 (abfd, src->e_version);
246 dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
248 dst->e_entry = H_GET_WORD (abfd, src->e_entry);
249 dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
250 dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
251 dst->e_flags = H_GET_32 (abfd, src->e_flags);
252 dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
253 dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
254 dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
255 dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
256 dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
257 dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
260 /* Translate an ELF file header in internal format into an ELF file header in
264 elf_swap_ehdr_out (bfd *abfd,
265 const Elf_Internal_Ehdr *src,
266 Elf_External_Ehdr *dst)
269 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
270 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
271 /* note that all elements of dst are *arrays of unsigned char* already... */
272 H_PUT_16 (abfd, src->e_type, dst->e_type);
273 H_PUT_16 (abfd, src->e_machine, dst->e_machine);
274 H_PUT_32 (abfd, src->e_version, dst->e_version);
276 H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
278 H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
279 H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
280 H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
281 H_PUT_32 (abfd, src->e_flags, dst->e_flags);
282 H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
283 H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
287 H_PUT_16 (abfd, tmp, dst->e_phnum);
288 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
290 if (tmp >= (SHN_LORESERVE & 0xffff))
292 H_PUT_16 (abfd, tmp, dst->e_shnum);
293 tmp = src->e_shstrndx;
294 if (tmp >= (SHN_LORESERVE & 0xffff))
295 tmp = SHN_XINDEX & 0xffff;
296 H_PUT_16 (abfd, tmp, dst->e_shstrndx);
299 /* Translate an ELF section header table entry in external format into an
300 ELF section header table entry in internal format. */
303 elf_swap_shdr_in (bfd *abfd,
304 const Elf_External_Shdr *src,
305 Elf_Internal_Shdr *dst)
307 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
309 dst->sh_name = H_GET_32 (abfd, src->sh_name);
310 dst->sh_type = H_GET_32 (abfd, src->sh_type);
311 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
313 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
315 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
316 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
317 dst->sh_size = H_GET_WORD (abfd, src->sh_size);
318 dst->sh_link = H_GET_32 (abfd, src->sh_link);
319 dst->sh_info = H_GET_32 (abfd, src->sh_info);
320 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
321 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
322 dst->bfd_section = NULL;
323 dst->contents = NULL;
326 /* Translate an ELF section header table entry in internal format into an
327 ELF section header table entry in external format. */
330 elf_swap_shdr_out (bfd *abfd,
331 const Elf_Internal_Shdr *src,
332 Elf_External_Shdr *dst)
334 /* note that all elements of dst are *arrays of unsigned char* already... */
335 H_PUT_32 (abfd, src->sh_name, dst->sh_name);
336 H_PUT_32 (abfd, src->sh_type, dst->sh_type);
337 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
338 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
339 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
340 H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
341 H_PUT_32 (abfd, src->sh_link, dst->sh_link);
342 H_PUT_32 (abfd, src->sh_info, dst->sh_info);
343 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
344 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
347 /* Translate an ELF program header table entry in external format into an
348 ELF program header table entry in internal format. */
351 elf_swap_phdr_in (bfd *abfd,
352 const Elf_External_Phdr *src,
353 Elf_Internal_Phdr *dst)
355 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
357 dst->p_type = H_GET_32 (abfd, src->p_type);
358 dst->p_flags = H_GET_32 (abfd, src->p_flags);
359 dst->p_offset = H_GET_WORD (abfd, src->p_offset);
362 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
363 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
367 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
368 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
370 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
371 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
372 dst->p_align = H_GET_WORD (abfd, src->p_align);
376 elf_swap_phdr_out (bfd *abfd,
377 const Elf_Internal_Phdr *src,
378 Elf_External_Phdr *dst)
380 const struct elf_backend_data *bed;
383 bed = get_elf_backend_data (abfd);
384 p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
386 /* note that all elements of dst are *arrays of unsigned char* already... */
387 H_PUT_32 (abfd, src->p_type, dst->p_type);
388 H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
389 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
390 H_PUT_WORD (abfd, p_paddr, dst->p_paddr);
391 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
392 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
393 H_PUT_32 (abfd, src->p_flags, dst->p_flags);
394 H_PUT_WORD (abfd, src->p_align, dst->p_align);
397 /* Translate an ELF reloc from external format to internal format. */
399 elf_swap_reloc_in (bfd *abfd,
401 Elf_Internal_Rela *dst)
403 const Elf_External_Rel *src = (const Elf_External_Rel *) s;
404 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
405 dst->r_info = H_GET_WORD (abfd, src->r_info);
410 elf_swap_reloca_in (bfd *abfd,
412 Elf_Internal_Rela *dst)
414 const Elf_External_Rela *src = (const Elf_External_Rela *) s;
415 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
416 dst->r_info = H_GET_WORD (abfd, src->r_info);
417 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
420 /* Translate an ELF reloc from internal format to external format. */
422 elf_swap_reloc_out (bfd *abfd,
423 const Elf_Internal_Rela *src,
426 Elf_External_Rel *dst = (Elf_External_Rel *) d;
427 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
428 H_PUT_WORD (abfd, src->r_info, dst->r_info);
432 elf_swap_reloca_out (bfd *abfd,
433 const Elf_Internal_Rela *src,
436 Elf_External_Rela *dst = (Elf_External_Rela *) d;
437 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
438 H_PUT_WORD (abfd, src->r_info, dst->r_info);
439 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
443 elf_swap_dyn_in (bfd *abfd,
445 Elf_Internal_Dyn *dst)
447 const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
449 dst->d_tag = H_GET_WORD (abfd, src->d_tag);
450 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
454 elf_swap_dyn_out (bfd *abfd,
455 const Elf_Internal_Dyn *src,
458 Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
460 H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
461 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
464 /* ELF .o/exec file reading */
466 /* Begin processing a given object.
468 First we validate the file by reading in the ELF header and checking
471 static inline bfd_boolean
472 elf_file_p (Elf_External_Ehdr *x_ehdrp)
474 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
475 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
476 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
477 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
480 /* Check to see if the file associated with ABFD matches the target vector
483 Note that we may be called several times with the same ABFD, but different
484 target vectors, most of which will not match. We have to avoid leaving
485 any side effects in ABFD, or any data it points to (like tdata), if the
486 file does not match the target vector. */
489 elf_object_p (bfd *abfd)
491 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
492 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
493 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
494 Elf_Internal_Shdr i_shdr;
495 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
496 unsigned int shindex;
497 const struct elf_backend_data *ebd;
498 struct bfd_preserve preserve;
501 const bfd_target *target;
502 const bfd_target * const *target_ptr;
504 preserve.marker = NULL;
506 /* Read in the ELF header in external format. */
508 if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
510 if (bfd_get_error () != bfd_error_system_call)
511 goto got_wrong_format_error;
516 /* Now check to see if we have a valid ELF file, and one that BFD can
517 make use of. The magic number must match, the address size ('class')
518 and byte-swapping must match our XVEC entry, and it must have a
519 section header table (FIXME: See comments re sections at top of this
522 if (! elf_file_p (&x_ehdr)
523 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
524 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
525 goto got_wrong_format_error;
527 /* Check that file's byte order matches xvec's */
528 switch (x_ehdr.e_ident[EI_DATA])
530 case ELFDATA2MSB: /* Big-endian */
531 if (! bfd_header_big_endian (abfd))
532 goto got_wrong_format_error;
534 case ELFDATA2LSB: /* Little-endian */
535 if (! bfd_header_little_endian (abfd))
536 goto got_wrong_format_error;
538 case ELFDATANONE: /* No data encoding specified */
539 default: /* Unknown data encoding specified */
540 goto got_wrong_format_error;
543 if (!bfd_preserve_save (abfd, &preserve))
548 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
549 the tdata pointer in the bfd. */
551 if (! (*target->_bfd_set_format[bfd_object]) (abfd))
553 preserve.marker = elf_tdata (abfd);
555 /* Now that we know the byte order, swap in the rest of the header */
556 i_ehdrp = elf_elfheader (abfd);
557 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
559 elf_debug_file (i_ehdrp);
562 /* Reject ET_CORE (header indicates core file, not object file) */
563 if (i_ehdrp->e_type == ET_CORE)
564 goto got_wrong_format_error;
566 /* If this is a relocatable file and there is no section header
567 table, then we're hosed. */
568 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
569 goto got_wrong_format_error;
571 /* As a simple sanity check, verify that what BFD thinks is the
572 size of each section header table entry actually matches the size
573 recorded in the file, but only if there are any sections. */
574 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
575 goto got_wrong_format_error;
577 /* Further sanity check. */
578 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
579 goto got_wrong_format_error;
581 ebd = get_elf_backend_data (abfd);
582 if (ebd->s->arch_size != ARCH_SIZE)
583 goto got_wrong_format_error;
585 /* Check that the ELF e_machine field matches what this particular
586 BFD format expects. */
587 if (ebd->elf_machine_code != i_ehdrp->e_machine
588 && (ebd->elf_machine_alt1 == 0
589 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
590 && (ebd->elf_machine_alt2 == 0
591 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
593 if (ebd->elf_machine_code != EM_NONE)
594 goto got_wrong_format_error;
596 /* This is the generic ELF target. Let it match any ELF target
597 for which we do not have a specific backend. */
598 if (abfd->target_defaulted)
599 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
601 const struct elf_backend_data *back;
603 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
605 back = xvec_get_elf_backend_data (*target_ptr);
606 if (back->s->arch_size != ARCH_SIZE)
608 if (back->elf_machine_code == i_ehdrp->e_machine
609 || (back->elf_machine_alt1 != 0
610 && back->elf_machine_alt1 == i_ehdrp->e_machine)
611 || (back->elf_machine_alt2 != 0
612 && back->elf_machine_alt2 == i_ehdrp->e_machine))
614 /* target_ptr is an ELF backend which matches this
615 object file, so reject the generic ELF target. */
616 goto got_wrong_format_error;
621 if (i_ehdrp->e_type == ET_EXEC)
622 abfd->flags |= EXEC_P;
623 else if (i_ehdrp->e_type == ET_DYN)
624 abfd->flags |= DYNAMIC;
626 if (i_ehdrp->e_phnum > 0)
627 abfd->flags |= D_PAGED;
629 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
631 /* It's OK if this fails for the generic target. */
632 if (ebd->elf_machine_code != EM_NONE)
636 if (ebd->elf_machine_code != EM_NONE
637 && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi)
639 if (ebd->elf_osabi != ELFOSABI_NONE)
640 goto got_wrong_format_error;
642 /* This is an ELFOSABI_NONE ELF target. Let it match any ELF
643 target of the compatible machine for which we do not have a
644 backend with matching ELFOSABI. */
645 for (target_ptr = bfd_target_vector;
649 const struct elf_backend_data *back;
651 /* Skip this target and targets with incompatible byte
653 if (*target_ptr == target
654 || (*target_ptr)->flavour != bfd_target_elf_flavour
655 || (*target_ptr)->byteorder != target->byteorder
656 || ((*target_ptr)->header_byteorder
657 != target->header_byteorder))
660 back = xvec_get_elf_backend_data (*target_ptr);
661 if (back->elf_osabi == i_ehdrp->e_ident[EI_OSABI]
662 && (back->elf_machine_code == i_ehdrp->e_machine
663 || (back->elf_machine_alt1 != 0
664 && back->elf_machine_alt1 == i_ehdrp->e_machine)
665 || (back->elf_machine_alt2 != 0
666 && back->elf_machine_alt2 == i_ehdrp->e_machine)))
668 /* target_ptr is an ELF backend which matches this
669 object file, so reject the ELFOSABI_NONE ELF target. */
670 goto got_wrong_format_error;
675 if (i_ehdrp->e_shoff != 0)
677 bfd_signed_vma where = i_ehdrp->e_shoff;
679 if (where != (file_ptr) where)
680 goto got_wrong_format_error;
682 /* Seek to the section header table in the file. */
683 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
686 /* Read the first section header at index 0, and convert to internal
688 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
690 elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
692 /* If the section count is zero, the actual count is in the first
694 if (i_ehdrp->e_shnum == SHN_UNDEF)
696 i_ehdrp->e_shnum = i_shdr.sh_size;
697 if (i_ehdrp->e_shnum != i_shdr.sh_size
698 || i_ehdrp->e_shnum == 0)
699 goto got_wrong_format_error;
702 /* And similarly for the string table index. */
703 if (i_ehdrp->e_shstrndx == (SHN_XINDEX & 0xffff))
705 i_ehdrp->e_shstrndx = i_shdr.sh_link;
706 if (i_ehdrp->e_shstrndx != i_shdr.sh_link)
707 goto got_wrong_format_error;
710 /* And program headers. */
711 if (i_ehdrp->e_phnum == PN_XNUM && i_shdr.sh_info != 0)
713 i_ehdrp->e_phnum = i_shdr.sh_info;
714 if (i_ehdrp->e_phnum != i_shdr.sh_info)
715 goto got_wrong_format_error;
718 /* Sanity check that we can read all of the section headers.
719 It ought to be good enough to just read the last one. */
720 if (i_ehdrp->e_shnum != 1)
722 /* Check that we don't have a totally silly number of sections. */
723 if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr)
724 || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr))
725 goto got_wrong_format_error;
727 where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr);
728 if (where != (file_ptr) where)
729 goto got_wrong_format_error;
730 if ((bfd_size_type) where <= i_ehdrp->e_shoff)
731 goto got_wrong_format_error;
733 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
735 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
738 /* Back to where we were. */
739 where = i_ehdrp->e_shoff + sizeof (x_shdr);
740 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
745 /* Allocate space for a copy of the section header table in
747 if (i_ehdrp->e_shnum != 0)
749 Elf_Internal_Shdr *shdrp;
750 unsigned int num_sec;
752 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
753 i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
756 num_sec = i_ehdrp->e_shnum;
757 elf_numsections (abfd) = num_sec;
758 amt = sizeof (i_shdrp) * num_sec;
759 elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
760 if (!elf_elfsections (abfd))
763 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
764 for (shdrp = i_shdrp, shindex = 0; shindex < num_sec; shindex++)
765 elf_elfsections (abfd)[shindex] = shdrp++;
767 /* Read in the rest of the section header table and convert it
769 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
771 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
773 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
775 /* Sanity check sh_link and sh_info. */
776 if (i_shdrp[shindex].sh_link >= num_sec)
778 /* PR 10478: Accept Solaris binaries with a sh_link
779 field set to SHN_BEFORE or SHN_AFTER. */
780 switch (ebd->elf_machine_code)
789 if (i_shdrp[shindex].sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
790 || i_shdrp[shindex].sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
792 /* Otherwise fall through. */
794 goto got_wrong_format_error;
798 if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK)
799 || i_shdrp[shindex].sh_type == SHT_RELA
800 || i_shdrp[shindex].sh_type == SHT_REL)
801 && i_shdrp[shindex].sh_info >= num_sec)
802 goto got_wrong_format_error;
804 /* If the section is loaded, but not page aligned, clear
806 if (i_shdrp[shindex].sh_size != 0
807 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
808 && i_shdrp[shindex].sh_type != SHT_NOBITS
809 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
812 abfd->flags &= ~D_PAGED;
816 /* A further sanity check. */
817 if (i_ehdrp->e_shnum != 0)
819 if (i_ehdrp->e_shstrndx >= elf_numsections (abfd))
822 We used to just goto got_wrong_format_error here
823 but there are binaries in existance for which this test
824 will prevent the binutils from working with them at all.
825 So we are kind, and reset the string index value to 0
826 so that at least some processing can be done. */
827 i_ehdrp->e_shstrndx = SHN_UNDEF;
828 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd->filename);
831 else if (i_ehdrp->e_shstrndx != SHN_UNDEF)
832 goto got_wrong_format_error;
834 /* Read in the program headers. */
835 if (i_ehdrp->e_phnum == 0)
836 elf_tdata (abfd)->phdr = NULL;
839 Elf_Internal_Phdr *i_phdr;
842 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
843 elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
844 if (elf_tdata (abfd)->phdr == NULL)
846 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
848 i_phdr = elf_tdata (abfd)->phdr;
849 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
851 Elf_External_Phdr x_phdr;
853 if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
855 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
859 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0)
861 unsigned int num_sec;
863 /* Once all of the section headers have been read and converted, we
864 can start processing them. Note that the first section header is
865 a dummy placeholder entry, so we ignore it. */
866 num_sec = elf_numsections (abfd);
867 for (shindex = 1; shindex < num_sec; shindex++)
868 if (!bfd_section_from_shdr (abfd, shindex))
871 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
872 if (! _bfd_elf_setup_sections (abfd))
873 goto got_wrong_format_error;
876 /* Let the backend double check the format and override global
878 if (ebd->elf_backend_object_p)
880 if (! (*ebd->elf_backend_object_p) (abfd))
881 goto got_wrong_format_error;
884 /* Remember the entry point specified in the ELF file header. */
885 bfd_set_start_address (abfd, i_ehdrp->e_entry);
887 /* If we have created any reloc sections that are associated with
888 debugging sections, mark the reloc sections as debugging as well. */
889 for (s = abfd->sections; s != NULL; s = s->next)
891 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
892 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
893 && elf_section_data (s)->this_hdr.sh_info > 0)
895 unsigned long targ_index;
898 targ_index = elf_section_data (s)->this_hdr.sh_info;
899 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
901 && (targ_sec->flags & SEC_DEBUGGING) != 0)
902 s->flags |= SEC_DEBUGGING;
906 bfd_preserve_finish (abfd, &preserve);
909 got_wrong_format_error:
910 /* There is way too much undoing of half-known state here. The caller,
911 bfd_check_format_matches, really shouldn't iterate on live bfd's to
912 check match/no-match like it does. We have to rely on that a call to
913 bfd_default_set_arch_mach with the previously known mach, undoes what
914 was done by the first bfd_default_set_arch_mach (with mach 0) here.
915 For this to work, only elf-data and the mach may be changed by the
916 target-specific elf_backend_object_p function. Note that saving the
917 whole bfd here and restoring it would be even worse; the first thing
918 you notice is that the cached bfd file position gets out of sync. */
919 bfd_set_error (bfd_error_wrong_format);
922 if (preserve.marker != NULL)
923 bfd_preserve_restore (abfd, &preserve);
927 /* ELF .o/exec file writing */
929 /* Write out the relocs. */
932 elf_write_relocs (bfd *abfd, asection *sec, void *data)
934 bfd_boolean *failedp = (bfd_boolean *) data;
935 Elf_Internal_Shdr *rela_hdr;
937 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
944 /* If we have already failed, don't do anything. */
948 if ((sec->flags & SEC_RELOC) == 0)
951 /* The linker backend writes the relocs out itself, and sets the
952 reloc_count field to zero to inhibit writing them here. Also,
953 sometimes the SEC_RELOC flag gets set even when there aren't any
955 if (sec->reloc_count == 0)
958 /* If we have opened an existing file for update, reloc_count may be
959 set even though we are not linking. In that case we have nothing
961 if (sec->orelocation == NULL)
964 rela_hdr = elf_section_data (sec)->rela.hdr;
965 if (rela_hdr == NULL)
966 rela_hdr = elf_section_data (sec)->rel.hdr;
968 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
969 rela_hdr->contents = (unsigned char *) bfd_alloc (abfd, rela_hdr->sh_size);
970 if (rela_hdr->contents == NULL)
976 /* Figure out whether the relocations are RELA or REL relocations. */
977 if (rela_hdr->sh_type == SHT_RELA)
979 swap_out = elf_swap_reloca_out;
980 extsize = sizeof (Elf_External_Rela);
982 else if (rela_hdr->sh_type == SHT_REL)
984 swap_out = elf_swap_reloc_out;
985 extsize = sizeof (Elf_External_Rel);
988 /* Every relocation section should be either an SHT_RELA or an
992 /* The address of an ELF reloc is section relative for an object
993 file, and absolute for an executable file or shared library.
994 The address of a BFD reloc is always section relative. */
996 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
997 addr_offset = sec->vma;
999 /* orelocation has the data, reloc_count has the count... */
1002 dst_rela = rela_hdr->contents;
1004 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
1006 Elf_Internal_Rela src_rela;
1011 ptr = sec->orelocation[idx];
1012 sym = *ptr->sym_ptr_ptr;
1013 if (sym == last_sym)
1015 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
1020 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
1029 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
1030 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
1031 && ! _bfd_elf_validate_reloc (abfd, ptr))
1037 src_rela.r_offset = ptr->address + addr_offset;
1038 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1039 src_rela.r_addend = ptr->addend;
1040 (*swap_out) (abfd, &src_rela, dst_rela);
1044 /* Write out the program headers. */
1047 elf_write_out_phdrs (bfd *abfd,
1048 const Elf_Internal_Phdr *phdr,
1053 Elf_External_Phdr extphdr;
1054 elf_swap_phdr_out (abfd, phdr, &extphdr);
1055 if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
1056 != sizeof (Elf_External_Phdr))
1063 /* Write out the section headers and the ELF file header. */
1066 elf_write_shdrs_and_ehdr (bfd *abfd)
1068 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1069 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
1070 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
1071 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
1075 i_ehdrp = elf_elfheader (abfd);
1076 i_shdrp = elf_elfsections (abfd);
1078 /* swap the header before spitting it out... */
1081 elf_debug_file (i_ehdrp);
1083 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1084 amt = sizeof (x_ehdr);
1085 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1086 || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
1089 /* Some fields in the first section header handle overflow of ehdr
1091 if (i_ehdrp->e_phnum >= PN_XNUM)
1092 i_shdrp[0]->sh_info = i_ehdrp->e_phnum;
1093 if (i_ehdrp->e_shnum >= (SHN_LORESERVE & 0xffff))
1094 i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1095 if (i_ehdrp->e_shstrndx >= (SHN_LORESERVE & 0xffff))
1096 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1098 /* at this point we've concocted all the ELF sections... */
1099 amt = i_ehdrp->e_shnum;
1100 amt *= sizeof (*x_shdrp);
1101 x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
1105 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1108 elf_debug_section (count, *i_shdrp);
1110 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1112 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1113 || bfd_bwrite (x_shdrp, amt, abfd) != amt)
1116 /* need to dump the string table too... */
1122 elf_checksum_contents (bfd *abfd,
1123 void (*process) (const void *, size_t, void *),
1126 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1127 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
1128 Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr;
1129 unsigned int count, num;
1132 Elf_External_Ehdr x_ehdr;
1133 Elf_Internal_Ehdr i_ehdr;
1136 i_ehdr.e_phoff = i_ehdr.e_shoff = 0;
1137 elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr);
1138 (*process) (&x_ehdr, sizeof x_ehdr, arg);
1141 num = i_ehdrp->e_phnum;
1142 for (count = 0; count < num; count++)
1144 Elf_External_Phdr x_phdr;
1145 elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr);
1146 (*process) (&x_phdr, sizeof x_phdr, arg);
1149 num = elf_numsections (abfd);
1150 for (count = 0; count < num; count++)
1152 Elf_Internal_Shdr i_shdr;
1153 Elf_External_Shdr x_shdr;
1155 i_shdr = *i_shdrp[count];
1156 i_shdr.sh_offset = 0;
1158 elf_swap_shdr_out (abfd, &i_shdr, &x_shdr);
1159 (*process) (&x_shdr, sizeof x_shdr, arg);
1161 if (i_shdr.contents)
1162 (*process) (i_shdr.contents, i_shdr.sh_size, arg);
1169 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
1171 Elf_Internal_Shdr *hdr;
1172 Elf_Internal_Shdr *verhdr;
1173 unsigned long symcount; /* Number of external ELF symbols */
1174 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1175 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1176 Elf_Internal_Sym *isym;
1177 Elf_Internal_Sym *isymend;
1178 Elf_Internal_Sym *isymbuf = NULL;
1179 Elf_External_Versym *xver;
1180 Elf_External_Versym *xverbuf = NULL;
1181 const struct elf_backend_data *ebd;
1184 /* Read each raw ELF symbol, converting from external ELF form to
1185 internal ELF form, and then using the information to create a
1186 canonical bfd symbol table entry.
1188 Note that we allocate the initial bfd canonical symbol buffer
1189 based on a one-to-one mapping of the ELF symbols to canonical
1190 symbols. We actually use all the ELF symbols, so there will be no
1191 space left over at the end. When we have all the symbols, we
1192 build the caller's pointer vector. */
1196 hdr = &elf_tdata (abfd)->symtab_hdr;
1201 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1202 if (elf_dynversym (abfd) == 0)
1205 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1206 if ((elf_tdata (abfd)->dynverdef_section != 0
1207 && elf_tdata (abfd)->verdef == NULL)
1208 || (elf_tdata (abfd)->dynverref_section != 0
1209 && elf_tdata (abfd)->verref == NULL))
1211 if (!_bfd_elf_slurp_version_tables (abfd, FALSE))
1216 ebd = get_elf_backend_data (abfd);
1217 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1219 sym = symbase = NULL;
1222 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1224 if (isymbuf == NULL)
1228 amt *= sizeof (elf_symbol_type);
1229 symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
1230 if (symbase == (elf_symbol_type *) NULL)
1233 /* Read the raw ELF version symbol information. */
1235 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1237 (*_bfd_error_handler)
1238 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1240 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1243 /* Slurp in the symbols without the version information,
1244 since that is more helpful than just quitting. */
1250 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1253 xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1254 if (xverbuf == NULL && verhdr->sh_size != 0)
1257 if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1261 /* Skip first symbol, which is a null dummy. */
1265 isymend = isymbuf + symcount;
1266 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1268 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1269 sym->symbol.the_bfd = abfd;
1271 sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL);
1273 sym->symbol.value = isym->st_value;
1275 if (isym->st_shndx == SHN_UNDEF)
1277 sym->symbol.section = bfd_und_section_ptr;
1279 else if (isym->st_shndx == SHN_ABS)
1281 sym->symbol.section = bfd_abs_section_ptr;
1283 else if (isym->st_shndx == SHN_COMMON)
1285 sym->symbol.section = bfd_com_section_ptr;
1286 if ((abfd->flags & BFD_PLUGIN) != 0)
1288 asection *xc = bfd_get_section_by_name (abfd, "COMMON");
1292 flagword flags = (SEC_ALLOC | SEC_IS_COMMON | SEC_KEEP
1294 xc = bfd_make_section_with_flags (abfd, "COMMON", flags);
1298 sym->symbol.section = xc;
1300 /* Elf puts the alignment into the `value' field, and
1301 the size into the `size' field. BFD wants to see the
1302 size in the value field, and doesn't care (at the
1303 moment) about the alignment. */
1304 sym->symbol.value = isym->st_size;
1309 = bfd_section_from_elf_index (abfd, isym->st_shndx);
1310 if (sym->symbol.section == NULL)
1312 /* This symbol is in a section for which we did not
1313 create a BFD section. Just use bfd_abs_section,
1314 although it is wrong. FIXME. */
1315 sym->symbol.section = bfd_abs_section_ptr;
1319 /* If this is a relocatable file, then the symbol value is
1320 already section relative. */
1321 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1322 sym->symbol.value -= sym->symbol.section->vma;
1324 switch (ELF_ST_BIND (isym->st_info))
1327 sym->symbol.flags |= BSF_LOCAL;
1330 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1331 sym->symbol.flags |= BSF_GLOBAL;
1334 sym->symbol.flags |= BSF_WEAK;
1336 case STB_GNU_UNIQUE:
1337 sym->symbol.flags |= BSF_GNU_UNIQUE;
1341 switch (ELF_ST_TYPE (isym->st_info))
1344 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1347 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1350 sym->symbol.flags |= BSF_FUNCTION;
1353 /* FIXME: Do we have to put the size field into the value field
1354 as we do with symbols in SHN_COMMON sections (see above) ? */
1357 sym->symbol.flags |= BSF_OBJECT;
1360 sym->symbol.flags |= BSF_THREAD_LOCAL;
1363 sym->symbol.flags |= BSF_RELC;
1366 sym->symbol.flags |= BSF_SRELC;
1369 sym->symbol.flags |= BSF_GNU_INDIRECT_FUNCTION;
1374 sym->symbol.flags |= BSF_DYNAMIC;
1378 Elf_Internal_Versym iversym;
1380 _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1381 sym->version = iversym.vs_vers;
1385 /* Do some backend-specific processing on this symbol. */
1386 if (ebd->elf_backend_symbol_processing)
1387 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1391 /* Do some backend-specific processing on this symbol table. */
1392 if (ebd->elf_backend_symbol_table_processing)
1393 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1395 /* We rely on the zalloc to clear out the final symbol entry. */
1397 symcount = sym - symbase;
1399 /* Fill in the user's symbol pointer vector if needed. */
1407 *symptrs++ = &sym->symbol;
1410 *symptrs = 0; /* Final null pointer */
1413 if (xverbuf != NULL)
1415 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1420 if (xverbuf != NULL)
1422 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1427 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1431 elf_slurp_reloc_table_from_section (bfd *abfd,
1433 Elf_Internal_Shdr *rel_hdr,
1434 bfd_size_type reloc_count,
1437 bfd_boolean dynamic)
1439 const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1440 void *allocated = NULL;
1441 bfd_byte *native_relocs;
1445 unsigned int symcount;
1447 allocated = bfd_malloc (rel_hdr->sh_size);
1448 if (allocated == NULL)
1451 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1452 || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1453 != rel_hdr->sh_size))
1456 native_relocs = (bfd_byte *) allocated;
1458 entsize = rel_hdr->sh_entsize;
1459 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1460 || entsize == sizeof (Elf_External_Rela));
1463 symcount = bfd_get_dynamic_symcount (abfd);
1465 symcount = bfd_get_symcount (abfd);
1467 for (i = 0, relent = relents;
1469 i++, relent++, native_relocs += entsize)
1471 Elf_Internal_Rela rela;
1473 if (entsize == sizeof (Elf_External_Rela))
1474 elf_swap_reloca_in (abfd, native_relocs, &rela);
1476 elf_swap_reloc_in (abfd, native_relocs, &rela);
1478 /* The address of an ELF reloc is section relative for an object
1479 file, and absolute for an executable file or shared library.
1480 The address of a normal BFD reloc is always section relative,
1481 and the address of a dynamic reloc is absolute.. */
1482 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1483 relent->address = rela.r_offset;
1485 relent->address = rela.r_offset - asect->vma;
1487 if (ELF_R_SYM (rela.r_info) == STN_UNDEF)
1488 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1489 else if (ELF_R_SYM (rela.r_info) > symcount)
1491 (*_bfd_error_handler)
1492 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1493 abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1494 relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1500 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1502 relent->sym_ptr_ptr = ps;
1505 relent->addend = rela.r_addend;
1507 if ((entsize == sizeof (Elf_External_Rela)
1508 && ebd->elf_info_to_howto != NULL)
1509 || ebd->elf_info_to_howto_rel == NULL)
1510 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1512 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1515 if (allocated != NULL)
1521 if (allocated != NULL)
1526 /* Read in and swap the external relocs. */
1529 elf_slurp_reloc_table (bfd *abfd,
1532 bfd_boolean dynamic)
1534 struct bfd_elf_section_data * const d = elf_section_data (asect);
1535 Elf_Internal_Shdr *rel_hdr;
1536 Elf_Internal_Shdr *rel_hdr2;
1537 bfd_size_type reloc_count;
1538 bfd_size_type reloc_count2;
1542 if (asect->relocation != NULL)
1547 if ((asect->flags & SEC_RELOC) == 0
1548 || asect->reloc_count == 0)
1551 rel_hdr = d->rel.hdr;
1552 reloc_count = rel_hdr ? NUM_SHDR_ENTRIES (rel_hdr) : 0;
1553 rel_hdr2 = d->rela.hdr;
1554 reloc_count2 = rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0;
1556 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1557 BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
1558 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1563 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1564 case because relocations against this section may use the
1565 dynamic symbol table, and in that case bfd_section_from_shdr
1566 in elf.c does not update the RELOC_COUNT. */
1567 if (asect->size == 0)
1570 rel_hdr = &d->this_hdr;
1571 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1576 amt = (reloc_count + reloc_count2) * sizeof (arelent);
1577 relents = (arelent *) bfd_alloc (abfd, amt);
1578 if (relents == NULL)
1582 && !elf_slurp_reloc_table_from_section (abfd, asect,
1583 rel_hdr, reloc_count,
1589 && !elf_slurp_reloc_table_from_section (abfd, asect,
1590 rel_hdr2, reloc_count2,
1591 relents + reloc_count,
1595 asect->relocation = relents;
1601 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1603 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1604 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1607 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1608 (long) hdr->sh_name,
1609 (long) hdr->sh_type,
1610 (long) hdr->sh_flags);
1612 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1613 (long) hdr->sh_addr,
1614 (long) hdr->sh_offset,
1615 (long) hdr->sh_size);
1617 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1618 (long) hdr->sh_link,
1619 (long) hdr->sh_info,
1620 (long) hdr->sh_addralign);
1621 fprintf (stderr, "sh_entsize = %ld\n",
1622 (long) hdr->sh_entsize);
1629 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1631 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1632 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1633 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1634 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1635 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1636 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1637 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1641 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1642 reconstruct an ELF file by reading the segments out of remote memory
1643 based on the ELF file header at EHDR_VMA and the ELF program headers it
1644 points to. If not null, *LOADBASEP is filled in with the difference
1645 between the VMAs from which the segments were read, and the VMAs the
1646 file headers (and hence BFD's idea of each section's VMA) put them at.
1648 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1649 remote memory at target address VMA into the local buffer at MYADDR; it
1650 should return zero on success or an `errno' code on failure. TEMPL must
1651 be a BFD for a target with the word size and byte order found in the
1655 NAME(_bfd_elf,bfd_from_remote_memory)
1659 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
1661 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1662 Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form */
1663 Elf_External_Phdr *x_phdrs;
1664 Elf_Internal_Phdr *i_phdrs, *last_phdr;
1666 struct bfd_in_memory *bim;
1672 bfd_boolean loadbase_set;
1674 /* Read in the ELF header in external format. */
1675 err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr);
1678 bfd_set_error (bfd_error_system_call);
1683 /* Now check to see if we have a valid ELF file, and one that BFD can
1684 make use of. The magic number must match, the address size ('class')
1685 and byte-swapping must match our XVEC entry. */
1687 if (! elf_file_p (&x_ehdr)
1688 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1689 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1691 bfd_set_error (bfd_error_wrong_format);
1695 /* Check that file's byte order matches xvec's */
1696 switch (x_ehdr.e_ident[EI_DATA])
1698 case ELFDATA2MSB: /* Big-endian */
1699 if (! bfd_header_big_endian (templ))
1701 bfd_set_error (bfd_error_wrong_format);
1705 case ELFDATA2LSB: /* Little-endian */
1706 if (! bfd_header_little_endian (templ))
1708 bfd_set_error (bfd_error_wrong_format);
1712 case ELFDATANONE: /* No data encoding specified */
1713 default: /* Unknown data encoding specified */
1714 bfd_set_error (bfd_error_wrong_format);
1718 elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1720 /* The file header tells where to find the program headers.
1721 These are what we use to actually choose what to read. */
1723 if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1725 bfd_set_error (bfd_error_wrong_format);
1729 x_phdrs = (Elf_External_Phdr *)
1730 bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1731 if (x_phdrs == NULL)
1733 bfd_set_error (bfd_error_no_memory);
1736 err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs,
1737 i_ehdr.e_phnum * sizeof x_phdrs[0]);
1741 bfd_set_error (bfd_error_system_call);
1745 i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1749 loadbase = ehdr_vma;
1750 loadbase_set = FALSE;
1751 for (i = 0; i < i_ehdr.e_phnum; ++i)
1753 elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1754 if (i_phdrs[i].p_type == PT_LOAD)
1756 bfd_vma segment_end;
1757 segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1758 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1759 if (segment_end > (bfd_vma) contents_size)
1760 contents_size = segment_end;
1762 /* LOADADDR is the `Base address' from the gELF specification:
1763 `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1764 first PT_LOAD as PT_LOADs are ordered by P_VADDR. */
1765 if (!loadbase_set && (i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1767 loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1768 loadbase_set = TRUE;
1771 last_phdr = &i_phdrs[i];
1774 if (last_phdr == NULL)
1776 /* There were no PT_LOAD segments, so we don't have anything to read. */
1778 bfd_set_error (bfd_error_wrong_format);
1782 /* Trim the last segment so we don't bother with zeros in the last page
1783 that are off the end of the file. However, if the extra bit in that
1784 page includes the section headers, keep them. */
1785 if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1786 && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1787 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1789 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1790 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1791 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1792 contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1795 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1797 /* Now we know the size of the whole image we want read in. */
1798 contents = (bfd_byte *) bfd_zmalloc (contents_size);
1799 if (contents == NULL)
1802 bfd_set_error (bfd_error_no_memory);
1806 for (i = 0; i < i_ehdr.e_phnum; ++i)
1807 if (i_phdrs[i].p_type == PT_LOAD)
1809 bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1810 bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1811 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1812 if (end > (bfd_vma) contents_size)
1813 end = contents_size;
1814 err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1815 & -i_phdrs[i].p_align,
1816 contents + start, end - start);
1821 bfd_set_error (bfd_error_system_call);
1828 /* If the segments visible in memory didn't include the section headers,
1829 then clear them from the file header. */
1830 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1831 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1833 memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1834 memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1835 memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1838 /* This will normally have been in the first PT_LOAD segment. But it
1839 conceivably could be missing, and we might have just changed it. */
1840 memcpy (contents, &x_ehdr, sizeof x_ehdr);
1842 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1843 bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
1847 bfd_set_error (bfd_error_no_memory);
1850 nbfd = _bfd_new_bfd ();
1855 bfd_set_error (bfd_error_no_memory);
1858 nbfd->filename = "<in-memory>";
1859 nbfd->xvec = templ->xvec;
1860 bim->size = contents_size;
1861 bim->buffer = contents;
1862 nbfd->iostream = bim;
1863 nbfd->flags = BFD_IN_MEMORY;
1864 nbfd->iovec = &_bfd_memory_iovec;
1866 nbfd->direction = read_direction;
1867 nbfd->mtime = time (NULL);
1868 nbfd->mtime_set = TRUE;
1871 *loadbasep = loadbase;
1875 /* Function for ELF_R_INFO. */
1878 NAME(elf,r_info) (bfd_vma sym, bfd_vma type)
1880 return ELF_R_INFO (sym, type);
1883 /* Function for ELF_R_SYM. */
1886 NAME(elf,r_sym) (bfd_vma r_info)
1888 return ELF_R_SYM (r_info);
1891 #include "elfcore.h"
1893 /* Size-dependent data and functions. */
1894 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1895 sizeof (Elf_External_Ehdr),
1896 sizeof (Elf_External_Phdr),
1897 sizeof (Elf_External_Shdr),
1898 sizeof (Elf_External_Rel),
1899 sizeof (Elf_External_Rela),
1900 sizeof (Elf_External_Sym),
1901 sizeof (Elf_External_Dyn),
1902 sizeof (Elf_External_Note),
1905 ARCH_SIZE, LOG_FILE_ALIGN,
1906 ELFCLASS, EV_CURRENT,
1907 elf_write_out_phdrs,
1908 elf_write_shdrs_and_ehdr,
1909 elf_checksum_contents,
1912 elf_swap_symbol_out,
1913 elf_slurp_reloc_table,
1914 elf_slurp_symbol_table,