1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 Written by Fred Fish @ Cygnus Support, from information published
6 in "UNIX System V Release 4, Programmers Guide: ANSI C and
7 Programming Support Tools". Sufficient support for gdb.
9 Rewritten by Mark Eichin @ Cygnus Support, from information
10 published in "System V Application Binary Interface", chapters 4
11 and 5, as well as the various "Processor Supplement" documents
12 derived from it. Added support for assembler and other object file
13 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
14 Meissner (Open Software Foundation), and Peter Hoogenboom (University
15 of Utah) to finish and extend this.
17 This file is part of BFD, the Binary File Descriptor library.
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License, or
22 (at your option) any later version.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 GNU General Public License for more details.
29 You should have received a copy of the GNU General Public License
30 along with this program; if not, write to the Free Software
31 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
33 /* Problems and other issues to resolve.
35 (1) BFD expects there to be some fixed number of "sections" in
36 the object file. I.E. there is a "section_count" variable in the
37 bfd structure which contains the number of sections. However, ELF
38 supports multiple "views" of a file. In particular, with current
39 implementations, executable files typically have two tables, a
40 program header table and a section header table, both of which
41 partition the executable.
43 In ELF-speak, the "linking view" of the file uses the section header
44 table to access "sections" within the file, and the "execution view"
45 uses the program header table to access "segments" within the file.
46 "Segments" typically may contain all the data from one or more
49 Note that the section header table is optional in ELF executables,
50 but it is this information that is most useful to gdb. If the
51 section header table is missing, then gdb should probably try
52 to make do with the program header table. (FIXME)
54 (2) The code in this file is compiled twice, once in 32-bit mode and
55 once in 64-bit mode. More of it should be made size-independent
58 (3) ELF section symbols are handled rather sloppily now. This should
59 be cleaned up, and ELF section symbols reconciled with BFD section
62 (4) We need a published spec for 64-bit ELF. We've got some stuff here
63 that we're using for SPARC V9 64-bit chips, but don't assume that
69 #include "libiberty.h"
74 /* Renaming structures, typedefs, macros and functions to be size-specific. */
75 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
76 #define Elf_External_Sym NAME(Elf,External_Sym)
77 #define Elf_External_Shdr NAME(Elf,External_Shdr)
78 #define Elf_External_Phdr NAME(Elf,External_Phdr)
79 #define Elf_External_Rel NAME(Elf,External_Rel)
80 #define Elf_External_Rela NAME(Elf,External_Rela)
81 #define Elf_External_Dyn NAME(Elf,External_Dyn)
83 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
84 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
85 #define elf_core_file_matches_executable_p \
86 NAME(bfd_elf,core_file_matches_executable_p)
87 #define elf_object_p NAME(bfd_elf,object_p)
88 #define elf_core_file_p NAME(bfd_elf,core_file_p)
89 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
90 #define elf_get_dynamic_symtab_upper_bound \
91 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
92 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
93 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
94 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
95 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
96 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
97 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
98 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
99 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
100 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
101 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
102 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
103 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
104 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
105 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
106 #define elf_canonicalize_dynamic_symtab \
107 NAME(bfd_elf,canonicalize_dynamic_symtab)
108 #define elf_get_synthetic_symtab \
109 NAME(bfd_elf,get_synthetic_symtab)
110 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
111 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
112 #define elf_get_lineno NAME(bfd_elf,get_lineno)
113 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
114 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
115 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
116 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
117 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
118 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
119 #define elf_find_section NAME(bfd_elf,find_section)
120 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
121 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
122 #define elf_write_relocs NAME(bfd_elf,write_relocs)
123 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
126 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
127 #define ELF_R_SYM(X) ELF64_R_SYM(X)
128 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
129 #define ELFCLASS ELFCLASS64
131 #define LOG_FILE_ALIGN 3
134 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
135 #define ELF_R_SYM(X) ELF32_R_SYM(X)
136 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
137 #define ELFCLASS ELFCLASS32
139 #define LOG_FILE_ALIGN 2
143 static void elf_debug_section (int, Elf_Internal_Shdr *);
144 static void elf_debug_file (Elf_Internal_Ehdr *);
145 static char *elf_symbol_flags (flagword);
148 /* Structure swapping routines */
150 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
151 can be handled by explicitly specifying 32 bits or "the long type". */
153 #define H_PUT_WORD H_PUT_64
154 #define H_PUT_SIGNED_WORD H_PUT_S64
155 #define H_GET_WORD H_GET_64
156 #define H_GET_SIGNED_WORD H_GET_S64
159 #define H_PUT_WORD H_PUT_32
160 #define H_PUT_SIGNED_WORD H_PUT_S32
161 #define H_GET_WORD H_GET_32
162 #define H_GET_SIGNED_WORD H_GET_S32
165 /* Translate an ELF symbol in external format into an ELF symbol in internal
169 elf_swap_symbol_in (bfd *abfd,
172 Elf_Internal_Sym *dst)
174 const Elf_External_Sym *src = psrc;
175 const Elf_External_Sym_Shndx *shndx = pshn;
176 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
178 dst->st_name = H_GET_32 (abfd, src->st_name);
180 dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
182 dst->st_value = H_GET_WORD (abfd, src->st_value);
183 dst->st_size = H_GET_WORD (abfd, src->st_size);
184 dst->st_info = H_GET_8 (abfd, src->st_info);
185 dst->st_other = H_GET_8 (abfd, src->st_other);
186 dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
187 if (dst->st_shndx == SHN_XINDEX)
191 dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
195 /* Translate an ELF symbol in internal format into an ELF symbol in external
199 elf_swap_symbol_out (bfd *abfd,
200 const Elf_Internal_Sym *src,
205 Elf_External_Sym *dst = cdst;
206 H_PUT_32 (abfd, src->st_name, dst->st_name);
207 H_PUT_WORD (abfd, src->st_value, dst->st_value);
208 H_PUT_WORD (abfd, src->st_size, dst->st_size);
209 H_PUT_8 (abfd, src->st_info, dst->st_info);
210 H_PUT_8 (abfd, src->st_other, dst->st_other);
212 if (tmp > SHN_HIRESERVE)
216 H_PUT_32 (abfd, tmp, shndx);
219 H_PUT_16 (abfd, tmp, dst->st_shndx);
222 /* Translate an ELF file header in external format into an ELF file header in
226 elf_swap_ehdr_in (bfd *abfd,
227 const Elf_External_Ehdr *src,
228 Elf_Internal_Ehdr *dst)
230 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
231 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
232 dst->e_type = H_GET_16 (abfd, src->e_type);
233 dst->e_machine = H_GET_16 (abfd, src->e_machine);
234 dst->e_version = H_GET_32 (abfd, src->e_version);
236 dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
238 dst->e_entry = H_GET_WORD (abfd, src->e_entry);
239 dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
240 dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
241 dst->e_flags = H_GET_32 (abfd, src->e_flags);
242 dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
243 dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
244 dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
245 dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
246 dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
247 dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
250 /* Translate an ELF file header in internal format into an ELF file header in
254 elf_swap_ehdr_out (bfd *abfd,
255 const Elf_Internal_Ehdr *src,
256 Elf_External_Ehdr *dst)
259 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
260 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
261 /* note that all elements of dst are *arrays of unsigned char* already... */
262 H_PUT_16 (abfd, src->e_type, dst->e_type);
263 H_PUT_16 (abfd, src->e_machine, dst->e_machine);
264 H_PUT_32 (abfd, src->e_version, dst->e_version);
266 H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
268 H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
269 H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
270 H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
271 H_PUT_32 (abfd, src->e_flags, dst->e_flags);
272 H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
273 H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
274 H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
275 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
277 if (tmp >= SHN_LORESERVE)
279 H_PUT_16 (abfd, tmp, dst->e_shnum);
280 tmp = src->e_shstrndx;
281 if (tmp >= SHN_LORESERVE)
283 H_PUT_16 (abfd, tmp, dst->e_shstrndx);
286 /* Translate an ELF section header table entry in external format into an
287 ELF section header table entry in internal format. */
290 elf_swap_shdr_in (bfd *abfd,
291 const Elf_External_Shdr *src,
292 Elf_Internal_Shdr *dst)
294 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
296 dst->sh_name = H_GET_32 (abfd, src->sh_name);
297 dst->sh_type = H_GET_32 (abfd, src->sh_type);
298 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
300 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
302 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
303 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
304 dst->sh_size = H_GET_WORD (abfd, src->sh_size);
305 dst->sh_link = H_GET_32 (abfd, src->sh_link);
306 dst->sh_info = H_GET_32 (abfd, src->sh_info);
307 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
308 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
309 dst->bfd_section = NULL;
310 dst->contents = NULL;
313 /* Translate an ELF section header table entry in internal format into an
314 ELF section header table entry in external format. */
317 elf_swap_shdr_out (bfd *abfd,
318 const Elf_Internal_Shdr *src,
319 Elf_External_Shdr *dst)
321 /* note that all elements of dst are *arrays of unsigned char* already... */
322 H_PUT_32 (abfd, src->sh_name, dst->sh_name);
323 H_PUT_32 (abfd, src->sh_type, dst->sh_type);
324 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
325 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
326 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
327 H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
328 H_PUT_32 (abfd, src->sh_link, dst->sh_link);
329 H_PUT_32 (abfd, src->sh_info, dst->sh_info);
330 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
331 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
334 /* Translate an ELF program header table entry in external format into an
335 ELF program header table entry in internal format. */
338 elf_swap_phdr_in (bfd *abfd,
339 const Elf_External_Phdr *src,
340 Elf_Internal_Phdr *dst)
342 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
344 dst->p_type = H_GET_32 (abfd, src->p_type);
345 dst->p_flags = H_GET_32 (abfd, src->p_flags);
346 dst->p_offset = H_GET_WORD (abfd, src->p_offset);
349 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
350 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
354 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
355 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
357 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
358 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
359 dst->p_align = H_GET_WORD (abfd, src->p_align);
363 elf_swap_phdr_out (bfd *abfd,
364 const Elf_Internal_Phdr *src,
365 Elf_External_Phdr *dst)
367 /* note that all elements of dst are *arrays of unsigned char* already... */
368 H_PUT_32 (abfd, src->p_type, dst->p_type);
369 H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
370 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
371 H_PUT_WORD (abfd, src->p_paddr, dst->p_paddr);
372 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
373 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
374 H_PUT_32 (abfd, src->p_flags, dst->p_flags);
375 H_PUT_WORD (abfd, src->p_align, dst->p_align);
378 /* Translate an ELF reloc from external format to internal format. */
380 elf_swap_reloc_in (bfd *abfd,
382 Elf_Internal_Rela *dst)
384 const Elf_External_Rel *src = (const Elf_External_Rel *) s;
385 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
386 dst->r_info = H_GET_WORD (abfd, src->r_info);
391 elf_swap_reloca_in (bfd *abfd,
393 Elf_Internal_Rela *dst)
395 const Elf_External_Rela *src = (const Elf_External_Rela *) s;
396 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
397 dst->r_info = H_GET_WORD (abfd, src->r_info);
398 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
401 /* Translate an ELF reloc from internal format to external format. */
403 elf_swap_reloc_out (bfd *abfd,
404 const Elf_Internal_Rela *src,
407 Elf_External_Rel *dst = (Elf_External_Rel *) d;
408 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
409 H_PUT_WORD (abfd, src->r_info, dst->r_info);
413 elf_swap_reloca_out (bfd *abfd,
414 const Elf_Internal_Rela *src,
417 Elf_External_Rela *dst = (Elf_External_Rela *) d;
418 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
419 H_PUT_WORD (abfd, src->r_info, dst->r_info);
420 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
424 elf_swap_dyn_in (bfd *abfd,
426 Elf_Internal_Dyn *dst)
428 const Elf_External_Dyn *src = p;
430 dst->d_tag = H_GET_WORD (abfd, src->d_tag);
431 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
435 elf_swap_dyn_out (bfd *abfd,
436 const Elf_Internal_Dyn *src,
439 Elf_External_Dyn *dst = p;
441 H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
442 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
445 /* ELF .o/exec file reading */
447 /* Begin processing a given object.
449 First we validate the file by reading in the ELF header and checking
452 static inline bfd_boolean
453 elf_file_p (Elf_External_Ehdr *x_ehdrp)
455 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
456 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
457 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
458 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
461 /* Determines if a given section index is valid. */
463 static inline bfd_boolean
464 valid_section_index_p (unsigned index, unsigned num_sections)
466 /* Note: We allow SHN_UNDEF as a valid section index. */
467 if (index < SHN_LORESERVE || index > SHN_HIRESERVE)
468 return index < num_sections;
470 /* We disallow the use of reserved indcies, except for those
471 with OS or Application specific meaning. The test make use
472 of the knowledge that:
473 SHN_LORESERVE == SHN_LOPROC
475 SHN_HIPROC == SHN_LOOS - 1 */
476 /* XXX - Should we allow SHN_XINDEX as a valid index here ? */
477 return (index >= SHN_LOPROC && index <= SHN_HIOS);
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;
502 preserve.marker = NULL;
504 /* Read in the ELF header in external format. */
506 if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
508 if (bfd_get_error () != bfd_error_system_call)
509 goto got_wrong_format_error;
514 /* Now check to see if we have a valid ELF file, and one that BFD can
515 make use of. The magic number must match, the address size ('class')
516 and byte-swapping must match our XVEC entry, and it must have a
517 section header table (FIXME: See comments re sections at top of this
520 if (! elf_file_p (&x_ehdr)
521 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
522 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
523 goto got_wrong_format_error;
525 /* Check that file's byte order matches xvec's */
526 switch (x_ehdr.e_ident[EI_DATA])
528 case ELFDATA2MSB: /* Big-endian */
529 if (! bfd_header_big_endian (abfd))
530 goto got_wrong_format_error;
532 case ELFDATA2LSB: /* Little-endian */
533 if (! bfd_header_little_endian (abfd))
534 goto got_wrong_format_error;
536 case ELFDATANONE: /* No data encoding specified */
537 default: /* Unknown data encoding specified */
538 goto got_wrong_format_error;
541 if (!bfd_preserve_save (abfd, &preserve))
544 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
545 the tdata pointer in the bfd. */
547 if (! (*abfd->xvec->_bfd_set_format[bfd_object]) (abfd))
549 preserve.marker = elf_tdata (abfd);
551 /* Now that we know the byte order, swap in the rest of the header */
552 i_ehdrp = elf_elfheader (abfd);
553 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
555 elf_debug_file (i_ehdrp);
558 /* Reject ET_CORE (header indicates core file, not object file) */
559 if (i_ehdrp->e_type == ET_CORE)
560 goto got_wrong_format_error;
562 /* If this is a relocatable file and there is no section header
563 table, then we're hosed. */
564 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
565 goto got_wrong_format_error;
567 /* As a simple sanity check, verify that what BFD thinks is the
568 size of each section header table entry actually matches the size
569 recorded in the file, but only if there are any sections. */
570 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
571 goto got_wrong_format_error;
573 /* Further sanity check. */
574 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
575 goto got_wrong_format_error;
577 ebd = get_elf_backend_data (abfd);
579 /* Check that the ELF e_machine field matches what this particular
580 BFD format expects. */
581 if (ebd->elf_machine_code != i_ehdrp->e_machine
582 && (ebd->elf_machine_alt1 == 0
583 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
584 && (ebd->elf_machine_alt2 == 0
585 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
587 const bfd_target * const *target_ptr;
589 if (ebd->elf_machine_code != EM_NONE)
590 goto got_wrong_format_error;
592 /* This is the generic ELF target. Let it match any ELF target
593 for which we do not have a specific backend. */
594 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
596 const struct elf_backend_data *back;
598 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
600 back = (const struct elf_backend_data *) (*target_ptr)->backend_data;
601 if (back->elf_machine_code == i_ehdrp->e_machine
602 || (back->elf_machine_alt1 != 0
603 && back->elf_machine_alt1 == i_ehdrp->e_machine)
604 || (back->elf_machine_alt2 != 0
605 && back->elf_machine_alt2 == i_ehdrp->e_machine))
607 /* target_ptr is an ELF backend which matches this
608 object file, so reject the generic ELF target. */
609 goto got_wrong_format_error;
614 if (i_ehdrp->e_type == ET_EXEC)
615 abfd->flags |= EXEC_P;
616 else if (i_ehdrp->e_type == ET_DYN)
617 abfd->flags |= DYNAMIC;
619 if (i_ehdrp->e_phnum > 0)
620 abfd->flags |= D_PAGED;
622 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
624 /* It's OK if this fails for the generic target. */
625 if (ebd->elf_machine_code != EM_NONE)
629 if (i_ehdrp->e_shoff != 0)
631 bfd_signed_vma where = i_ehdrp->e_shoff;
633 if (where != (file_ptr) where)
634 goto got_wrong_format_error;
636 /* Seek to the section header table in the file. */
637 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
640 /* Read the first section header at index 0, and convert to internal
642 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
644 elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
646 /* If the section count is zero, the actual count is in the first
648 if (i_ehdrp->e_shnum == SHN_UNDEF)
650 i_ehdrp->e_shnum = i_shdr.sh_size;
651 if (i_ehdrp->e_shnum != i_shdr.sh_size
652 || i_ehdrp->e_shnum == 0)
653 goto got_wrong_format_error;
656 /* And similarly for the string table index. */
657 if (i_ehdrp->e_shstrndx == SHN_XINDEX)
659 i_ehdrp->e_shstrndx = i_shdr.sh_link;
660 if (i_ehdrp->e_shstrndx != i_shdr.sh_link)
661 goto got_wrong_format_error;
664 /* Sanity check that we can read all of the section headers.
665 It ought to be good enough to just read the last one. */
666 if (i_ehdrp->e_shnum != 1)
668 /* Check that we don't have a totally silly number of sections. */
669 if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr)
670 || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr))
671 goto got_wrong_format_error;
673 where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr);
674 if (where != (file_ptr) where)
675 goto got_wrong_format_error;
676 if ((bfd_size_type) where <= i_ehdrp->e_shoff)
677 goto got_wrong_format_error;
679 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
681 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
684 /* Back to where we were. */
685 where = i_ehdrp->e_shoff + sizeof (x_shdr);
686 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
691 /* Allocate space for a copy of the section header table in
693 if (i_ehdrp->e_shnum != 0)
695 Elf_Internal_Shdr *shdrp;
696 unsigned int num_sec;
698 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
699 i_shdrp = bfd_alloc (abfd, amt);
702 num_sec = i_ehdrp->e_shnum;
703 if (num_sec > SHN_LORESERVE)
704 num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE;
705 elf_numsections (abfd) = num_sec;
706 amt = sizeof (i_shdrp) * num_sec;
707 elf_elfsections (abfd) = bfd_alloc (abfd, amt);
708 if (!elf_elfsections (abfd))
711 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
714 if (num_sec > SHN_LORESERVE)
716 for ( ; shindex < SHN_LORESERVE; shindex++)
717 elf_elfsections (abfd)[shindex] = shdrp++;
718 for ( ; shindex < SHN_HIRESERVE + 1; shindex++)
719 elf_elfsections (abfd)[shindex] = i_shdrp;
721 for ( ; shindex < num_sec; shindex++)
722 elf_elfsections (abfd)[shindex] = shdrp++;
724 /* Read in the rest of the section header table and convert it
726 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
728 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
730 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
732 /* Sanity check sh_link and sh_info. */
733 if (! valid_section_index_p (i_shdrp[shindex].sh_link, num_sec))
734 goto got_wrong_format_error;
736 if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK)
737 || i_shdrp[shindex].sh_type == SHT_RELA
738 || i_shdrp[shindex].sh_type == SHT_REL)
739 && ! valid_section_index_p (i_shdrp[shindex].sh_info, num_sec))
740 goto got_wrong_format_error;
742 /* If the section is loaded, but not page aligned, clear
744 if (i_shdrp[shindex].sh_size != 0
745 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
746 && i_shdrp[shindex].sh_type != SHT_NOBITS
747 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
750 abfd->flags &= ~D_PAGED;
754 /* A further sanity check. */
755 if (i_ehdrp->e_shnum != 0)
757 if (! valid_section_index_p (i_ehdrp->e_shstrndx, elf_numsections (abfd)))
760 We used to just goto got_wrong_format_error here
761 but there are binaries in existance for which this test
762 will prevent the binutils from working with them at all.
763 So we are kind, and reset the string index value to 0
764 so that at least some processing can be done. */
765 i_ehdrp->e_shstrndx = SHN_UNDEF;
766 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd->filename);
769 else if (i_ehdrp->e_shstrndx != SHN_UNDEF)
770 goto got_wrong_format_error;
772 /* Read in the program headers. */
773 if (i_ehdrp->e_phnum == 0)
774 elf_tdata (abfd)->phdr = NULL;
777 Elf_Internal_Phdr *i_phdr;
780 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
781 elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt);
782 if (elf_tdata (abfd)->phdr == NULL)
784 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
786 i_phdr = elf_tdata (abfd)->phdr;
787 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
789 Elf_External_Phdr x_phdr;
791 if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
793 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
797 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0)
799 unsigned int num_sec;
801 /* Once all of the section headers have been read and converted, we
802 can start processing them. Note that the first section header is
803 a dummy placeholder entry, so we ignore it. */
804 num_sec = elf_numsections (abfd);
805 for (shindex = 1; shindex < num_sec; shindex++)
807 if (! bfd_section_from_shdr (abfd, shindex))
809 if (shindex == SHN_LORESERVE - 1)
810 shindex += SHN_HIRESERVE + 1 - SHN_LORESERVE;
813 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
814 if (! _bfd_elf_setup_sections (abfd))
815 goto got_wrong_format_error;
818 /* Let the backend double check the format and override global
820 if (ebd->elf_backend_object_p)
822 if (! (*ebd->elf_backend_object_p) (abfd))
823 goto got_wrong_format_error;
826 /* Remember the entry point specified in the ELF file header. */
827 bfd_set_start_address (abfd, i_ehdrp->e_entry);
829 /* If we have created any reloc sections that are associated with
830 debugging sections, mark the reloc sections as debugging as well. */
831 for (s = abfd->sections; s != NULL; s = s->next)
833 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
834 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
835 && elf_section_data (s)->this_hdr.sh_info > 0)
837 unsigned long targ_index;
840 targ_index = elf_section_data (s)->this_hdr.sh_info;
841 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
843 && (targ_sec->flags & SEC_DEBUGGING) != 0)
844 s->flags |= SEC_DEBUGGING;
848 bfd_preserve_finish (abfd, &preserve);
851 got_wrong_format_error:
852 /* There is way too much undoing of half-known state here. The caller,
853 bfd_check_format_matches, really shouldn't iterate on live bfd's to
854 check match/no-match like it does. We have to rely on that a call to
855 bfd_default_set_arch_mach with the previously known mach, undoes what
856 was done by the first bfd_default_set_arch_mach (with mach 0) here.
857 For this to work, only elf-data and the mach may be changed by the
858 target-specific elf_backend_object_p function. Note that saving the
859 whole bfd here and restoring it would be even worse; the first thing
860 you notice is that the cached bfd file position gets out of sync. */
861 bfd_set_error (bfd_error_wrong_format);
864 if (preserve.marker != NULL)
865 bfd_preserve_restore (abfd, &preserve);
869 /* ELF .o/exec file writing */
871 /* Write out the relocs. */
874 elf_write_relocs (bfd *abfd, asection *sec, void *data)
876 bfd_boolean *failedp = data;
877 Elf_Internal_Shdr *rela_hdr;
879 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
886 /* If we have already failed, don't do anything. */
890 if ((sec->flags & SEC_RELOC) == 0)
893 /* The linker backend writes the relocs out itself, and sets the
894 reloc_count field to zero to inhibit writing them here. Also,
895 sometimes the SEC_RELOC flag gets set even when there aren't any
897 if (sec->reloc_count == 0)
900 /* If we have opened an existing file for update, reloc_count may be
901 set even though we are not linking. In that case we have nothing
903 if (sec->orelocation == NULL)
906 rela_hdr = &elf_section_data (sec)->rel_hdr;
908 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
909 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
910 if (rela_hdr->contents == NULL)
916 /* Figure out whether the relocations are RELA or REL relocations. */
917 if (rela_hdr->sh_type == SHT_RELA)
919 swap_out = elf_swap_reloca_out;
920 extsize = sizeof (Elf_External_Rela);
922 else if (rela_hdr->sh_type == SHT_REL)
924 swap_out = elf_swap_reloc_out;
925 extsize = sizeof (Elf_External_Rel);
928 /* Every relocation section should be either an SHT_RELA or an
932 /* The address of an ELF reloc is section relative for an object
933 file, and absolute for an executable file or shared library.
934 The address of a BFD reloc is always section relative. */
936 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
937 addr_offset = sec->vma;
939 /* orelocation has the data, reloc_count has the count... */
942 dst_rela = rela_hdr->contents;
944 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
946 Elf_Internal_Rela src_rela;
951 ptr = sec->orelocation[idx];
952 sym = *ptr->sym_ptr_ptr;
955 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
960 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
969 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
970 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
971 && ! _bfd_elf_validate_reloc (abfd, ptr))
977 src_rela.r_offset = ptr->address + addr_offset;
978 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
979 src_rela.r_addend = ptr->addend;
980 (*swap_out) (abfd, &src_rela, dst_rela);
984 /* Write out the program headers. */
987 elf_write_out_phdrs (bfd *abfd,
988 const Elf_Internal_Phdr *phdr,
993 Elf_External_Phdr extphdr;
994 elf_swap_phdr_out (abfd, phdr, &extphdr);
995 if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
996 != sizeof (Elf_External_Phdr))
1003 /* Write out the section headers and the ELF file header. */
1006 elf_write_shdrs_and_ehdr (bfd *abfd)
1008 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1009 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
1010 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
1011 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
1015 i_ehdrp = elf_elfheader (abfd);
1016 i_shdrp = elf_elfsections (abfd);
1018 /* swap the header before spitting it out... */
1021 elf_debug_file (i_ehdrp);
1023 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1024 amt = sizeof (x_ehdr);
1025 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1026 || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
1029 /* Some fields in the first section header handle overflow of ehdr
1031 if (i_ehdrp->e_shnum >= SHN_LORESERVE)
1032 i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1033 if (i_ehdrp->e_shstrndx >= SHN_LORESERVE)
1034 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1036 /* at this point we've concocted all the ELF sections... */
1037 amt = i_ehdrp->e_shnum;
1038 amt *= sizeof (*x_shdrp);
1039 x_shdrp = bfd_alloc (abfd, amt);
1043 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1046 elf_debug_section (count, *i_shdrp);
1048 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1050 if (count == SHN_LORESERVE - 1)
1051 i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
1053 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1054 || bfd_bwrite (x_shdrp, amt, abfd) != amt)
1057 /* need to dump the string table too... */
1063 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
1065 Elf_Internal_Shdr *hdr;
1066 Elf_Internal_Shdr *verhdr;
1067 unsigned long symcount; /* Number of external ELF symbols */
1068 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1069 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1070 Elf_Internal_Sym *isym;
1071 Elf_Internal_Sym *isymend;
1072 Elf_Internal_Sym *isymbuf = NULL;
1073 Elf_External_Versym *xver;
1074 Elf_External_Versym *xverbuf = NULL;
1075 const struct elf_backend_data *ebd;
1078 /* Read each raw ELF symbol, converting from external ELF form to
1079 internal ELF form, and then using the information to create a
1080 canonical bfd symbol table entry.
1082 Note that we allocate the initial bfd canonical symbol buffer
1083 based on a one-to-one mapping of the ELF symbols to canonical
1084 symbols. We actually use all the ELF symbols, so there will be no
1085 space left over at the end. When we have all the symbols, we
1086 build the caller's pointer vector. */
1090 hdr = &elf_tdata (abfd)->symtab_hdr;
1095 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1096 if (elf_dynversym (abfd) == 0)
1099 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1100 if ((elf_tdata (abfd)->dynverdef_section != 0
1101 && elf_tdata (abfd)->verdef == NULL)
1102 || (elf_tdata (abfd)->dynverref_section != 0
1103 && elf_tdata (abfd)->verref == NULL))
1105 if (!_bfd_elf_slurp_version_tables (abfd, FALSE))
1110 ebd = get_elf_backend_data (abfd);
1111 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1113 sym = symbase = NULL;
1116 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1118 if (isymbuf == NULL)
1122 amt *= sizeof (elf_symbol_type);
1123 symbase = bfd_zalloc (abfd, amt);
1124 if (symbase == (elf_symbol_type *) NULL)
1127 /* Read the raw ELF version symbol information. */
1129 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1131 (*_bfd_error_handler)
1132 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1134 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1137 /* Slurp in the symbols without the version information,
1138 since that is more helpful than just quitting. */
1144 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1147 xverbuf = bfd_malloc (verhdr->sh_size);
1148 if (xverbuf == NULL && verhdr->sh_size != 0)
1151 if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1155 /* Skip first symbol, which is a null dummy. */
1159 isymend = isymbuf + symcount;
1160 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1162 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1163 sym->symbol.the_bfd = abfd;
1165 sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL);
1167 sym->symbol.value = isym->st_value;
1169 if (isym->st_shndx == SHN_UNDEF)
1171 sym->symbol.section = bfd_und_section_ptr;
1173 else if (isym->st_shndx < SHN_LORESERVE
1174 || isym->st_shndx > SHN_HIRESERVE)
1176 sym->symbol.section = bfd_section_from_elf_index (abfd,
1178 if (sym->symbol.section == NULL)
1180 /* This symbol is in a section for which we did not
1181 create a BFD section. Just use bfd_abs_section,
1182 although it is wrong. FIXME. */
1183 sym->symbol.section = bfd_abs_section_ptr;
1186 else if (isym->st_shndx == SHN_ABS)
1188 sym->symbol.section = bfd_abs_section_ptr;
1190 else if (isym->st_shndx == SHN_COMMON)
1192 sym->symbol.section = bfd_com_section_ptr;
1193 /* Elf puts the alignment into the `value' field, and
1194 the size into the `size' field. BFD wants to see the
1195 size in the value field, and doesn't care (at the
1196 moment) about the alignment. */
1197 sym->symbol.value = isym->st_size;
1200 sym->symbol.section = bfd_abs_section_ptr;
1202 /* If this is a relocatable file, then the symbol value is
1203 already section relative. */
1204 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1205 sym->symbol.value -= sym->symbol.section->vma;
1207 switch (ELF_ST_BIND (isym->st_info))
1210 sym->symbol.flags |= BSF_LOCAL;
1213 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1214 sym->symbol.flags |= BSF_GLOBAL;
1217 sym->symbol.flags |= BSF_WEAK;
1221 switch (ELF_ST_TYPE (isym->st_info))
1224 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1227 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1230 sym->symbol.flags |= BSF_FUNCTION;
1233 sym->symbol.flags |= BSF_OBJECT;
1236 sym->symbol.flags |= BSF_THREAD_LOCAL;
1241 sym->symbol.flags |= BSF_DYNAMIC;
1245 Elf_Internal_Versym iversym;
1247 _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1248 sym->version = iversym.vs_vers;
1252 /* Do some backend-specific processing on this symbol. */
1253 if (ebd->elf_backend_symbol_processing)
1254 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1258 /* Do some backend-specific processing on this symbol table. */
1259 if (ebd->elf_backend_symbol_table_processing)
1260 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1262 /* We rely on the zalloc to clear out the final symbol entry. */
1264 symcount = sym - symbase;
1266 /* Fill in the user's symbol pointer vector if needed. */
1274 *symptrs++ = &sym->symbol;
1277 *symptrs = 0; /* Final null pointer */
1280 if (xverbuf != NULL)
1282 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1287 if (xverbuf != NULL)
1289 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1294 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1298 elf_slurp_reloc_table_from_section (bfd *abfd,
1300 Elf_Internal_Shdr *rel_hdr,
1301 bfd_size_type reloc_count,
1304 bfd_boolean dynamic)
1306 const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1307 void *allocated = NULL;
1308 bfd_byte *native_relocs;
1312 unsigned int symcount;
1314 allocated = bfd_malloc (rel_hdr->sh_size);
1315 if (allocated == NULL)
1318 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1319 || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1320 != rel_hdr->sh_size))
1323 native_relocs = allocated;
1325 entsize = rel_hdr->sh_entsize;
1326 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1327 || entsize == sizeof (Elf_External_Rela));
1330 symcount = bfd_get_dynamic_symcount (abfd);
1332 symcount = bfd_get_symcount (abfd);
1334 for (i = 0, relent = relents;
1336 i++, relent++, native_relocs += entsize)
1338 Elf_Internal_Rela rela;
1340 if (entsize == sizeof (Elf_External_Rela))
1341 elf_swap_reloca_in (abfd, native_relocs, &rela);
1343 elf_swap_reloc_in (abfd, native_relocs, &rela);
1345 /* The address of an ELF reloc is section relative for an object
1346 file, and absolute for an executable file or shared library.
1347 The address of a normal BFD reloc is always section relative,
1348 and the address of a dynamic reloc is absolute.. */
1349 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1350 relent->address = rela.r_offset;
1352 relent->address = rela.r_offset - asect->vma;
1354 if (ELF_R_SYM (rela.r_info) == 0)
1355 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1356 else if (ELF_R_SYM (rela.r_info) > symcount)
1358 (*_bfd_error_handler)
1359 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1360 abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1361 relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1367 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1369 relent->sym_ptr_ptr = ps;
1372 relent->addend = rela.r_addend;
1374 if ((entsize == sizeof (Elf_External_Rela)
1375 && ebd->elf_info_to_howto != NULL)
1376 || ebd->elf_info_to_howto_rel == NULL)
1377 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1379 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1382 if (allocated != NULL)
1388 if (allocated != NULL)
1393 /* Read in and swap the external relocs. */
1396 elf_slurp_reloc_table (bfd *abfd,
1399 bfd_boolean dynamic)
1401 struct bfd_elf_section_data * const d = elf_section_data (asect);
1402 Elf_Internal_Shdr *rel_hdr;
1403 Elf_Internal_Shdr *rel_hdr2;
1404 bfd_size_type reloc_count;
1405 bfd_size_type reloc_count2;
1409 if (asect->relocation != NULL)
1414 if ((asect->flags & SEC_RELOC) == 0
1415 || asect->reloc_count == 0)
1418 rel_hdr = &d->rel_hdr;
1419 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1420 rel_hdr2 = d->rel_hdr2;
1421 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1423 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1424 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1425 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1430 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1431 case because relocations against this section may use the
1432 dynamic symbol table, and in that case bfd_section_from_shdr
1433 in elf.c does not update the RELOC_COUNT. */
1434 if (asect->size == 0)
1437 rel_hdr = &d->this_hdr;
1438 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1443 amt = (reloc_count + reloc_count2) * sizeof (arelent);
1444 relents = bfd_alloc (abfd, amt);
1445 if (relents == NULL)
1448 if (!elf_slurp_reloc_table_from_section (abfd, asect,
1449 rel_hdr, reloc_count,
1455 && !elf_slurp_reloc_table_from_section (abfd, asect,
1456 rel_hdr2, reloc_count2,
1457 relents + reloc_count,
1461 asect->relocation = relents;
1467 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1469 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1470 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1473 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1474 (long) hdr->sh_name,
1475 (long) hdr->sh_type,
1476 (long) hdr->sh_flags);
1478 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1479 (long) hdr->sh_addr,
1480 (long) hdr->sh_offset,
1481 (long) hdr->sh_size);
1483 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1484 (long) hdr->sh_link,
1485 (long) hdr->sh_info,
1486 (long) hdr->sh_addralign);
1487 fprintf (stderr, "sh_entsize = %ld\n",
1488 (long) hdr->sh_entsize);
1493 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1495 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1496 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1497 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1498 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1499 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1500 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1501 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1505 elf_symbol_flags (flagword flags)
1507 static char buffer[1024];
1510 if (flags & BSF_LOCAL)
1511 strcat (buffer, " local");
1513 if (flags & BSF_GLOBAL)
1514 strcat (buffer, " global");
1516 if (flags & BSF_DEBUGGING)
1517 strcat (buffer, " debug");
1519 if (flags & BSF_FUNCTION)
1520 strcat (buffer, " function");
1522 if (flags & BSF_KEEP)
1523 strcat (buffer, " keep");
1525 if (flags & BSF_KEEP_G)
1526 strcat (buffer, " keep_g");
1528 if (flags & BSF_WEAK)
1529 strcat (buffer, " weak");
1531 if (flags & BSF_SECTION_SYM)
1532 strcat (buffer, " section-sym");
1534 if (flags & BSF_OLD_COMMON)
1535 strcat (buffer, " old-common");
1537 if (flags & BSF_NOT_AT_END)
1538 strcat (buffer, " not-at-end");
1540 if (flags & BSF_CONSTRUCTOR)
1541 strcat (buffer, " constructor");
1543 if (flags & BSF_WARNING)
1544 strcat (buffer, " warning");
1546 if (flags & BSF_INDIRECT)
1547 strcat (buffer, " indirect");
1549 if (flags & BSF_FILE)
1550 strcat (buffer, " file");
1552 if (flags & DYNAMIC)
1553 strcat (buffer, " dynamic");
1555 if (flags & ~(BSF_LOCAL
1570 strcat (buffer, " unknown-bits");
1576 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1577 reconstruct an ELF file by reading the segments out of remote memory
1578 based on the ELF file header at EHDR_VMA and the ELF program headers it
1579 points to. If not null, *LOADBASEP is filled in with the difference
1580 between the VMAs from which the segments were read, and the VMAs the
1581 file headers (and hence BFD's idea of each section's VMA) put them at.
1583 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1584 remote memory at target address VMA into the local buffer at MYADDR; it
1585 should return zero on success or an `errno' code on failure. TEMPL must
1586 be a BFD for a target with the word size and byte order found in the
1590 NAME(_bfd_elf,bfd_from_remote_memory)
1594 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
1596 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1597 Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form */
1598 Elf_External_Phdr *x_phdrs;
1599 Elf_Internal_Phdr *i_phdrs, *last_phdr;
1601 struct bfd_in_memory *bim;
1608 /* Read in the ELF header in external format. */
1609 err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr);
1612 bfd_set_error (bfd_error_system_call);
1617 /* Now check to see if we have a valid ELF file, and one that BFD can
1618 make use of. The magic number must match, the address size ('class')
1619 and byte-swapping must match our XVEC entry. */
1621 if (! elf_file_p (&x_ehdr)
1622 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1623 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1625 bfd_set_error (bfd_error_wrong_format);
1629 /* Check that file's byte order matches xvec's */
1630 switch (x_ehdr.e_ident[EI_DATA])
1632 case ELFDATA2MSB: /* Big-endian */
1633 if (! bfd_header_big_endian (templ))
1635 bfd_set_error (bfd_error_wrong_format);
1639 case ELFDATA2LSB: /* Little-endian */
1640 if (! bfd_header_little_endian (templ))
1642 bfd_set_error (bfd_error_wrong_format);
1646 case ELFDATANONE: /* No data encoding specified */
1647 default: /* Unknown data encoding specified */
1648 bfd_set_error (bfd_error_wrong_format);
1652 elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1654 /* The file header tells where to find the program headers.
1655 These are what we use to actually choose what to read. */
1657 if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1659 bfd_set_error (bfd_error_wrong_format);
1663 x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1664 if (x_phdrs == NULL)
1666 bfd_set_error (bfd_error_no_memory);
1669 err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs,
1670 i_ehdr.e_phnum * sizeof x_phdrs[0]);
1674 bfd_set_error (bfd_error_system_call);
1678 i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1682 loadbase = ehdr_vma;
1683 for (i = 0; i < i_ehdr.e_phnum; ++i)
1685 elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1686 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1687 is executable only, and one is read only. We must not use the
1689 if (i_phdrs[i].p_type == PT_LOAD && (i_phdrs[i].p_flags & PF_R))
1691 bfd_vma segment_end;
1692 segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1693 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1694 if (segment_end > (bfd_vma) contents_size)
1695 contents_size = segment_end;
1697 if ((i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1698 loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1700 last_phdr = &i_phdrs[i];
1703 if (last_phdr == NULL)
1705 /* There were no PT_LOAD segments, so we don't have anything to read. */
1707 bfd_set_error (bfd_error_wrong_format);
1711 /* Trim the last segment so we don't bother with zeros in the last page
1712 that are off the end of the file. However, if the extra bit in that
1713 page includes the section headers, keep them. */
1714 if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1715 && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1716 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1718 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1719 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1720 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1721 contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1724 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1726 /* Now we know the size of the whole image we want read in. */
1727 contents = bfd_zmalloc (contents_size);
1728 if (contents == NULL)
1731 bfd_set_error (bfd_error_no_memory);
1735 for (i = 0; i < i_ehdr.e_phnum; ++i)
1736 /* IA-64 vDSO may have two mappings for one segment, where one mapping
1737 is executable only, and one is read only. We must not use the
1739 if (i_phdrs[i].p_type == PT_LOAD && (i_phdrs[i].p_flags & PF_R))
1741 bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1742 bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1743 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1744 if (end > (bfd_vma) contents_size)
1745 end = contents_size;
1746 err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1747 & -i_phdrs[i].p_align,
1748 contents + start, end - start);
1753 bfd_set_error (bfd_error_system_call);
1760 /* If the segments visible in memory didn't include the section headers,
1761 then clear them from the file header. */
1762 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1763 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1765 memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1766 memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1767 memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1770 /* This will normally have been in the first PT_LOAD segment. But it
1771 conceivably could be missing, and we might have just changed it. */
1772 memcpy (contents, &x_ehdr, sizeof x_ehdr);
1774 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1775 bim = bfd_malloc (sizeof (struct bfd_in_memory));
1779 bfd_set_error (bfd_error_no_memory);
1782 nbfd = _bfd_new_bfd ();
1787 bfd_set_error (bfd_error_no_memory);
1790 nbfd->filename = "<in-memory>";
1791 nbfd->xvec = templ->xvec;
1792 bim->size = contents_size;
1793 bim->buffer = contents;
1794 nbfd->iostream = bim;
1795 nbfd->flags = BFD_IN_MEMORY;
1796 nbfd->direction = read_direction;
1797 nbfd->mtime = time (NULL);
1798 nbfd->mtime_set = TRUE;
1801 *loadbasep = loadbase;
1805 #include "elfcore.h"
1807 /* Size-dependent data and functions. */
1808 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1809 sizeof (Elf_External_Ehdr),
1810 sizeof (Elf_External_Phdr),
1811 sizeof (Elf_External_Shdr),
1812 sizeof (Elf_External_Rel),
1813 sizeof (Elf_External_Rela),
1814 sizeof (Elf_External_Sym),
1815 sizeof (Elf_External_Dyn),
1816 sizeof (Elf_External_Note),
1819 ARCH_SIZE, LOG_FILE_ALIGN,
1820 ELFCLASS, EV_CURRENT,
1821 elf_write_out_phdrs,
1822 elf_write_shdrs_and_ehdr,
1825 elf_swap_symbol_out,
1826 elf_slurp_reloc_table,
1827 elf_slurp_symbol_table,