1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003 Free Software Foundation, Inc.
5 Written by Fred Fish @ Cygnus Support, from information published
6 in "UNIX System V Release 4, Programmers Guide: ANSI C and
7 Programming Support Tools". Sufficient support for gdb.
9 Rewritten by Mark Eichin @ Cygnus Support, from information
10 published in "System V Application Binary Interface", chapters 4
11 and 5, as well as the various "Processor Supplement" documents
12 derived from it. Added support for assembler and other object file
13 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
14 Meissner (Open Software Foundation), and Peter Hoogenboom (University
15 of Utah) to finish and extend this.
17 This file is part of BFD, the Binary File Descriptor library.
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License, or
22 (at your option) any later version.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 GNU General Public License for more details.
29 You should have received a copy of the GNU General Public License
30 along with this program; if not, write to the Free Software
31 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 /* Problems and other issues to resolve.
35 (1) BFD expects there to be some fixed number of "sections" in
36 the object file. I.E. there is a "section_count" variable in the
37 bfd structure which contains the number of sections. However, ELF
38 supports multiple "views" of a file. In particular, with current
39 implementations, executable files typically have two tables, a
40 program header table and a section header table, both of which
41 partition the executable.
43 In ELF-speak, the "linking view" of the file uses the section header
44 table to access "sections" within the file, and the "execution view"
45 uses the program header table to access "segments" within the file.
46 "Segments" typically may contain all the data from one or more
49 Note that the section header table is optional in ELF executables,
50 but it is this information that is most useful to gdb. If the
51 section header table is missing, then gdb should probably try
52 to make do with the program header table. (FIXME)
54 (2) The code in this file is compiled twice, once in 32-bit mode and
55 once in 64-bit mode. More of it should be made size-independent
58 (3) ELF section symbols are handled rather sloppily now. This should
59 be cleaned up, and ELF section symbols reconciled with BFD section
62 (4) We need a published spec for 64-bit ELF. We've got some stuff here
63 that we're using for SPARC V9 64-bit chips, but don't assume that
69 #include "libiberty.h"
74 /* Renaming structures, typedefs, macros and functions to be size-specific. */
75 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
76 #define Elf_External_Sym NAME(Elf,External_Sym)
77 #define Elf_External_Shdr NAME(Elf,External_Shdr)
78 #define Elf_External_Phdr NAME(Elf,External_Phdr)
79 #define Elf_External_Rel NAME(Elf,External_Rel)
80 #define Elf_External_Rela NAME(Elf,External_Rela)
81 #define Elf_External_Dyn NAME(Elf,External_Dyn)
83 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
84 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
85 #define elf_core_file_matches_executable_p \
86 NAME(bfd_elf,core_file_matches_executable_p)
87 #define elf_object_p NAME(bfd_elf,object_p)
88 #define elf_core_file_p NAME(bfd_elf,core_file_p)
89 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
90 #define elf_get_dynamic_symtab_upper_bound \
91 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
92 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
93 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
94 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
95 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
96 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
97 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
98 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
99 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
100 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
101 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
102 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
103 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
104 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
105 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
106 #define elf_canonicalize_dynamic_symtab \
107 NAME(bfd_elf,canonicalize_dynamic_symtab)
108 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
109 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
110 #define elf_get_lineno NAME(bfd_elf,get_lineno)
111 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
112 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
113 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
114 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
115 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
116 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
117 #define elf_find_section NAME(bfd_elf,find_section)
118 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
119 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
120 #define elf_write_relocs NAME(bfd_elf,write_relocs)
121 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
124 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
125 #define ELF_R_SYM(X) ELF64_R_SYM(X)
126 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
127 #define ELFCLASS ELFCLASS64
129 #define LOG_FILE_ALIGN 3
132 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
133 #define ELF_R_SYM(X) ELF32_R_SYM(X)
134 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
135 #define ELFCLASS ELFCLASS32
137 #define LOG_FILE_ALIGN 2
141 static void elf_debug_section (int, Elf_Internal_Shdr *);
142 static void elf_debug_file (Elf_Internal_Ehdr *);
143 static char *elf_symbol_flags (flagword);
146 /* Structure swapping routines */
148 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
149 can be handled by explicitly specifying 32 bits or "the long type". */
151 #define H_PUT_WORD H_PUT_64
152 #define H_PUT_SIGNED_WORD H_PUT_S64
153 #define H_GET_WORD H_GET_64
154 #define H_GET_SIGNED_WORD H_GET_S64
157 #define H_PUT_WORD H_PUT_32
158 #define H_PUT_SIGNED_WORD H_PUT_S32
159 #define H_GET_WORD H_GET_32
160 #define H_GET_SIGNED_WORD H_GET_S32
163 /* Translate an ELF symbol in external format into an ELF symbol in internal
167 elf_swap_symbol_in (bfd *abfd,
170 Elf_Internal_Sym *dst)
172 const Elf_External_Sym *src = psrc;
173 const Elf_External_Sym_Shndx *shndx = pshn;
174 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
176 dst->st_name = H_GET_32 (abfd, src->st_name);
178 dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
180 dst->st_value = H_GET_WORD (abfd, src->st_value);
181 dst->st_size = H_GET_WORD (abfd, src->st_size);
182 dst->st_info = H_GET_8 (abfd, src->st_info);
183 dst->st_other = H_GET_8 (abfd, src->st_other);
184 dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
185 if (dst->st_shndx == SHN_XINDEX)
189 dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
193 /* Translate an ELF symbol in internal format into an ELF symbol in external
197 elf_swap_symbol_out (bfd *abfd,
198 const Elf_Internal_Sym *src,
203 Elf_External_Sym *dst = cdst;
204 H_PUT_32 (abfd, src->st_name, dst->st_name);
205 H_PUT_WORD (abfd, src->st_value, dst->st_value);
206 H_PUT_WORD (abfd, src->st_size, dst->st_size);
207 H_PUT_8 (abfd, src->st_info, dst->st_info);
208 H_PUT_8 (abfd, src->st_other, dst->st_other);
210 if (tmp > SHN_HIRESERVE)
214 H_PUT_32 (abfd, tmp, shndx);
217 H_PUT_16 (abfd, tmp, dst->st_shndx);
220 /* Translate an ELF file header in external format into an ELF file header in
224 elf_swap_ehdr_in (bfd *abfd,
225 const Elf_External_Ehdr *src,
226 Elf_Internal_Ehdr *dst)
228 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
229 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
230 dst->e_type = H_GET_16 (abfd, src->e_type);
231 dst->e_machine = H_GET_16 (abfd, src->e_machine);
232 dst->e_version = H_GET_32 (abfd, src->e_version);
234 dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
236 dst->e_entry = H_GET_WORD (abfd, src->e_entry);
237 dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
238 dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
239 dst->e_flags = H_GET_32 (abfd, src->e_flags);
240 dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
241 dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
242 dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
243 dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
244 dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
245 dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
248 /* Translate an ELF file header in internal format into an ELF file header in
252 elf_swap_ehdr_out (bfd *abfd,
253 const Elf_Internal_Ehdr *src,
254 Elf_External_Ehdr *dst)
257 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
258 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
259 /* note that all elements of dst are *arrays of unsigned char* already... */
260 H_PUT_16 (abfd, src->e_type, dst->e_type);
261 H_PUT_16 (abfd, src->e_machine, dst->e_machine);
262 H_PUT_32 (abfd, src->e_version, dst->e_version);
264 H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
266 H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
267 H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
268 H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
269 H_PUT_32 (abfd, src->e_flags, dst->e_flags);
270 H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
271 H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
272 H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
273 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
275 if (tmp >= SHN_LORESERVE)
277 H_PUT_16 (abfd, tmp, dst->e_shnum);
278 tmp = src->e_shstrndx;
279 if (tmp >= SHN_LORESERVE)
281 H_PUT_16 (abfd, tmp, dst->e_shstrndx);
284 /* Translate an ELF section header table entry in external format into an
285 ELF section header table entry in internal format. */
288 elf_swap_shdr_in (bfd *abfd,
289 const Elf_External_Shdr *src,
290 Elf_Internal_Shdr *dst)
292 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
294 dst->sh_name = H_GET_32 (abfd, src->sh_name);
295 dst->sh_type = H_GET_32 (abfd, src->sh_type);
296 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
298 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
300 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
301 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
302 dst->sh_size = H_GET_WORD (abfd, src->sh_size);
303 dst->sh_link = H_GET_32 (abfd, src->sh_link);
304 dst->sh_info = H_GET_32 (abfd, src->sh_info);
305 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
306 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
307 dst->bfd_section = NULL;
308 dst->contents = NULL;
311 /* Translate an ELF section header table entry in internal format into an
312 ELF section header table entry in external format. */
315 elf_swap_shdr_out (bfd *abfd,
316 const Elf_Internal_Shdr *src,
317 Elf_External_Shdr *dst)
319 /* note that all elements of dst are *arrays of unsigned char* already... */
320 H_PUT_32 (abfd, src->sh_name, dst->sh_name);
321 H_PUT_32 (abfd, src->sh_type, dst->sh_type);
322 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
323 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
324 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
325 H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
326 H_PUT_32 (abfd, src->sh_link, dst->sh_link);
327 H_PUT_32 (abfd, src->sh_info, dst->sh_info);
328 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
329 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
332 /* Translate an ELF program header table entry in external format into an
333 ELF program header table entry in internal format. */
336 elf_swap_phdr_in (bfd *abfd,
337 const Elf_External_Phdr *src,
338 Elf_Internal_Phdr *dst)
340 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
342 dst->p_type = H_GET_32 (abfd, src->p_type);
343 dst->p_flags = H_GET_32 (abfd, src->p_flags);
344 dst->p_offset = H_GET_WORD (abfd, src->p_offset);
347 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
348 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
352 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
353 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
355 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
356 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
357 dst->p_align = H_GET_WORD (abfd, src->p_align);
361 elf_swap_phdr_out (bfd *abfd,
362 const Elf_Internal_Phdr *src,
363 Elf_External_Phdr *dst)
365 /* note that all elements of dst are *arrays of unsigned char* already... */
366 H_PUT_32 (abfd, src->p_type, dst->p_type);
367 H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
368 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
369 H_PUT_WORD (abfd, src->p_paddr, dst->p_paddr);
370 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
371 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
372 H_PUT_32 (abfd, src->p_flags, dst->p_flags);
373 H_PUT_WORD (abfd, src->p_align, dst->p_align);
376 /* Translate an ELF reloc from external format to internal format. */
378 elf_swap_reloc_in (bfd *abfd,
380 Elf_Internal_Rela *dst)
382 const Elf_External_Rel *src = (const Elf_External_Rel *) s;
383 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
384 dst->r_info = H_GET_WORD (abfd, src->r_info);
389 elf_swap_reloca_in (bfd *abfd,
391 Elf_Internal_Rela *dst)
393 const Elf_External_Rela *src = (const Elf_External_Rela *) s;
394 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
395 dst->r_info = H_GET_WORD (abfd, src->r_info);
396 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
399 /* Translate an ELF reloc from internal format to external format. */
401 elf_swap_reloc_out (bfd *abfd,
402 const Elf_Internal_Rela *src,
405 Elf_External_Rel *dst = (Elf_External_Rel *) d;
406 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
407 H_PUT_WORD (abfd, src->r_info, dst->r_info);
411 elf_swap_reloca_out (bfd *abfd,
412 const Elf_Internal_Rela *src,
415 Elf_External_Rela *dst = (Elf_External_Rela *) d;
416 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
417 H_PUT_WORD (abfd, src->r_info, dst->r_info);
418 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
422 elf_swap_dyn_in (bfd *abfd,
424 Elf_Internal_Dyn *dst)
426 const Elf_External_Dyn *src = p;
428 dst->d_tag = H_GET_WORD (abfd, src->d_tag);
429 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
433 elf_swap_dyn_out (bfd *abfd,
434 const Elf_Internal_Dyn *src,
437 Elf_External_Dyn *dst = p;
439 H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
440 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
443 /* ELF .o/exec file reading */
445 /* Begin processing a given object.
447 First we validate the file by reading in the ELF header and checking
450 static inline bfd_boolean
451 elf_file_p (Elf_External_Ehdr *x_ehdrp)
453 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
454 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
455 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
456 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
459 /* Check to see if the file associated with ABFD matches the target vector
462 Note that we may be called several times with the same ABFD, but different
463 target vectors, most of which will not match. We have to avoid leaving
464 any side effects in ABFD, or any data it points to (like tdata), if the
465 file does not match the target vector. */
468 elf_object_p (bfd *abfd)
470 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
471 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
472 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
473 Elf_Internal_Shdr i_shdr;
474 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
475 unsigned int shindex;
476 char *shstrtab; /* Internal copy of section header stringtab */
477 const struct elf_backend_data *ebd;
478 struct bfd_preserve preserve;
482 preserve.marker = NULL;
484 /* Read in the ELF header in external format. */
486 if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
488 if (bfd_get_error () != bfd_error_system_call)
489 goto got_wrong_format_error;
494 /* Now check to see if we have a valid ELF file, and one that BFD can
495 make use of. The magic number must match, the address size ('class')
496 and byte-swapping must match our XVEC entry, and it must have a
497 section header table (FIXME: See comments re sections at top of this
500 if (! elf_file_p (&x_ehdr)
501 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
502 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
503 goto got_wrong_format_error;
505 /* Check that file's byte order matches xvec's */
506 switch (x_ehdr.e_ident[EI_DATA])
508 case ELFDATA2MSB: /* Big-endian */
509 if (! bfd_header_big_endian (abfd))
510 goto got_wrong_format_error;
512 case ELFDATA2LSB: /* Little-endian */
513 if (! bfd_header_little_endian (abfd))
514 goto got_wrong_format_error;
516 case ELFDATANONE: /* No data encoding specified */
517 default: /* Unknown data encoding specified */
518 goto got_wrong_format_error;
521 if (!bfd_preserve_save (abfd, &preserve))
524 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
525 the tdata pointer in the bfd. */
527 if (! (*abfd->xvec->_bfd_set_format[bfd_object]) (abfd))
529 preserve.marker = elf_tdata (abfd);
531 /* Now that we know the byte order, swap in the rest of the header */
532 i_ehdrp = elf_elfheader (abfd);
533 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
535 elf_debug_file (i_ehdrp);
538 /* Reject ET_CORE (header indicates core file, not object file) */
539 if (i_ehdrp->e_type == ET_CORE)
540 goto got_wrong_format_error;
542 /* If this is a relocatable file and there is no section header
543 table, then we're hosed. */
544 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
545 goto got_wrong_format_error;
547 /* As a simple sanity check, verify that the what BFD thinks is the
548 size of each section header table entry actually matches the size
549 recorded in the file, but only if there are any sections. */
550 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
551 goto got_wrong_format_error;
553 /* Further sanity check. */
554 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
555 goto got_wrong_format_error;
557 ebd = get_elf_backend_data (abfd);
559 /* Check that the ELF e_machine field matches what this particular
560 BFD format expects. */
561 if (ebd->elf_machine_code != i_ehdrp->e_machine
562 && (ebd->elf_machine_alt1 == 0
563 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
564 && (ebd->elf_machine_alt2 == 0
565 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
567 const bfd_target * const *target_ptr;
569 if (ebd->elf_machine_code != EM_NONE)
570 goto got_wrong_format_error;
572 /* This is the generic ELF target. Let it match any ELF target
573 for which we do not have a specific backend. */
574 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
576 const struct elf_backend_data *back;
578 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
580 back = (const struct elf_backend_data *) (*target_ptr)->backend_data;
581 if (back->elf_machine_code == i_ehdrp->e_machine
582 || (back->elf_machine_alt1 != 0
583 && back->elf_machine_alt1 == i_ehdrp->e_machine)
584 || (back->elf_machine_alt2 != 0
585 && back->elf_machine_alt2 == i_ehdrp->e_machine))
587 /* target_ptr is an ELF backend which matches this
588 object file, so reject the generic ELF target. */
589 goto got_wrong_format_error;
594 if (i_ehdrp->e_type == ET_EXEC)
595 abfd->flags |= EXEC_P;
596 else if (i_ehdrp->e_type == ET_DYN)
597 abfd->flags |= DYNAMIC;
599 if (i_ehdrp->e_phnum > 0)
600 abfd->flags |= D_PAGED;
602 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
604 /* It's OK if this fails for the generic target. */
605 if (ebd->elf_machine_code != EM_NONE)
609 /* Remember the entry point specified in the ELF file header. */
610 bfd_set_start_address (abfd, i_ehdrp->e_entry);
612 if (i_ehdrp->e_shoff != 0)
614 /* Seek to the section header table in the file. */
615 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0)
618 /* Read the first section header at index 0, and convert to internal
620 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
622 elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
624 /* If the section count is zero, the actual count is in the first
626 if (i_ehdrp->e_shnum == SHN_UNDEF)
627 i_ehdrp->e_shnum = i_shdr.sh_size;
629 /* And similarly for the string table index. */
630 if (i_ehdrp->e_shstrndx == SHN_XINDEX)
631 i_ehdrp->e_shstrndx = i_shdr.sh_link;
634 /* Allocate space for a copy of the section header table in
636 if (i_ehdrp->e_shnum != 0)
638 Elf_Internal_Shdr *shdrp;
639 unsigned int num_sec;
641 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
642 i_shdrp = bfd_alloc (abfd, amt);
645 num_sec = i_ehdrp->e_shnum;
646 if (num_sec > SHN_LORESERVE)
647 num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE;
648 elf_numsections (abfd) = num_sec;
649 amt = sizeof (i_shdrp) * num_sec;
650 elf_elfsections (abfd) = bfd_alloc (abfd, amt);
651 if (!elf_elfsections (abfd))
654 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
657 if (num_sec > SHN_LORESERVE)
659 for ( ; shindex < SHN_LORESERVE; shindex++)
660 elf_elfsections (abfd)[shindex] = shdrp++;
661 for ( ; shindex < SHN_HIRESERVE + 1; shindex++)
662 elf_elfsections (abfd)[shindex] = i_shdrp;
664 for ( ; shindex < num_sec; shindex++)
665 elf_elfsections (abfd)[shindex] = shdrp++;
667 /* Read in the rest of the section header table and convert it
669 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
671 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
673 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
675 /* If the section is loaded, but not page aligned, clear
677 if (i_shdrp[shindex].sh_size != 0
678 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
679 && i_shdrp[shindex].sh_type != SHT_NOBITS
680 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
683 abfd->flags &= ~D_PAGED;
687 if (i_ehdrp->e_shstrndx && i_ehdrp->e_shoff)
689 if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
693 /* Read in the program headers. */
694 if (i_ehdrp->e_phnum == 0)
695 elf_tdata (abfd)->phdr = NULL;
698 Elf_Internal_Phdr *i_phdr;
701 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
702 elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt);
703 if (elf_tdata (abfd)->phdr == NULL)
705 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
707 i_phdr = elf_tdata (abfd)->phdr;
708 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
710 Elf_External_Phdr x_phdr;
712 if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
714 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
718 /* Read in the string table containing the names of the sections. We
719 will need the base pointer to this table later. */
720 /* We read this inline now, so that we don't have to go through
721 bfd_section_from_shdr with it (since this particular strtab is
722 used to find all of the ELF section names.) */
724 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff)
726 unsigned int num_sec;
728 shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
732 /* Once all of the section headers have been read and converted, we
733 can start processing them. Note that the first section header is
734 a dummy placeholder entry, so we ignore it. */
735 num_sec = elf_numsections (abfd);
736 for (shindex = 1; shindex < num_sec; shindex++)
738 if (! bfd_section_from_shdr (abfd, shindex))
740 if (shindex == SHN_LORESERVE - 1)
741 shindex += SHN_HIRESERVE + 1 - SHN_LORESERVE;
745 /* Let the backend double check the format and override global
747 if (ebd->elf_backend_object_p)
749 if (! (*ebd->elf_backend_object_p) (abfd))
750 goto got_wrong_format_error;
753 /* If we have created any reloc sections that are associated with
754 debugging sections, mark the reloc sections as debugging as well. */
755 for (s = abfd->sections; s != NULL; s = s->next)
757 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
758 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
759 && elf_section_data (s)->this_hdr.sh_info > 0)
761 unsigned long targ_index;
764 targ_index = elf_section_data (s)->this_hdr.sh_info;
765 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
767 && (targ_sec->flags & SEC_DEBUGGING) != 0)
768 s->flags |= SEC_DEBUGGING;
772 bfd_preserve_finish (abfd, &preserve);
775 got_wrong_format_error:
776 /* There is way too much undoing of half-known state here. The caller,
777 bfd_check_format_matches, really shouldn't iterate on live bfd's to
778 check match/no-match like it does. We have to rely on that a call to
779 bfd_default_set_arch_mach with the previously known mach, undoes what
780 was done by the first bfd_default_set_arch_mach (with mach 0) here.
781 For this to work, only elf-data and the mach may be changed by the
782 target-specific elf_backend_object_p function. Note that saving the
783 whole bfd here and restoring it would be even worse; the first thing
784 you notice is that the cached bfd file position gets out of sync. */
785 bfd_set_error (bfd_error_wrong_format);
788 if (preserve.marker != NULL)
789 bfd_preserve_restore (abfd, &preserve);
793 /* ELF .o/exec file writing */
795 /* Write out the relocs. */
798 elf_write_relocs (bfd *abfd, asection *sec, void *data)
800 bfd_boolean *failedp = data;
801 Elf_Internal_Shdr *rela_hdr;
803 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
810 /* If we have already failed, don't do anything. */
814 if ((sec->flags & SEC_RELOC) == 0)
817 /* The linker backend writes the relocs out itself, and sets the
818 reloc_count field to zero to inhibit writing them here. Also,
819 sometimes the SEC_RELOC flag gets set even when there aren't any
821 if (sec->reloc_count == 0)
824 rela_hdr = &elf_section_data (sec)->rel_hdr;
826 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
827 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
828 if (rela_hdr->contents == NULL)
834 /* Figure out whether the relocations are RELA or REL relocations. */
835 if (rela_hdr->sh_type == SHT_RELA)
837 swap_out = elf_swap_reloca_out;
838 extsize = sizeof (Elf_External_Rela);
840 else if (rela_hdr->sh_type == SHT_REL)
842 swap_out = elf_swap_reloc_out;
843 extsize = sizeof (Elf_External_Rel);
846 /* Every relocation section should be either an SHT_RELA or an
850 /* The address of an ELF reloc is section relative for an object
851 file, and absolute for an executable file or shared library.
852 The address of a BFD reloc is always section relative. */
854 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
855 addr_offset = sec->vma;
857 /* orelocation has the data, reloc_count has the count... */
860 dst_rela = rela_hdr->contents;
862 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
864 Elf_Internal_Rela src_rela;
869 ptr = sec->orelocation[idx];
870 sym = *ptr->sym_ptr_ptr;
873 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
878 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
887 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
888 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
889 && ! _bfd_elf_validate_reloc (abfd, ptr))
895 src_rela.r_offset = ptr->address + addr_offset;
896 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
897 src_rela.r_addend = ptr->addend;
898 (*swap_out) (abfd, &src_rela, dst_rela);
902 /* Write out the program headers. */
905 elf_write_out_phdrs (bfd *abfd,
906 const Elf_Internal_Phdr *phdr,
911 Elf_External_Phdr extphdr;
912 elf_swap_phdr_out (abfd, phdr, &extphdr);
913 if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
914 != sizeof (Elf_External_Phdr))
921 /* Write out the section headers and the ELF file header. */
924 elf_write_shdrs_and_ehdr (bfd *abfd)
926 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
927 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
928 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
929 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
933 i_ehdrp = elf_elfheader (abfd);
934 i_shdrp = elf_elfsections (abfd);
936 /* swap the header before spitting it out... */
939 elf_debug_file (i_ehdrp);
941 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
942 amt = sizeof (x_ehdr);
943 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
944 || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
947 /* Some fields in the first section header handle overflow of ehdr
949 if (i_ehdrp->e_shnum >= SHN_LORESERVE)
950 i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
951 if (i_ehdrp->e_shstrndx >= SHN_LORESERVE)
952 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
954 /* at this point we've concocted all the ELF sections... */
955 amt = i_ehdrp->e_shnum;
956 amt *= sizeof (*x_shdrp);
957 x_shdrp = bfd_alloc (abfd, amt);
961 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
964 elf_debug_section (count, *i_shdrp);
966 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
968 if (count == SHN_LORESERVE - 1)
969 i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
971 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
972 || bfd_bwrite (x_shdrp, amt, abfd) != amt)
975 /* need to dump the string table too... */
981 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
983 Elf_Internal_Shdr *hdr;
984 Elf_Internal_Shdr *verhdr;
985 unsigned long symcount; /* Number of external ELF symbols */
986 elf_symbol_type *sym; /* Pointer to current bfd symbol */
987 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
988 Elf_Internal_Sym *isym;
989 Elf_Internal_Sym *isymend;
990 Elf_Internal_Sym *isymbuf = NULL;
991 Elf_External_Versym *xver;
992 Elf_External_Versym *xverbuf = NULL;
993 const struct elf_backend_data *ebd;
996 /* Read each raw ELF symbol, converting from external ELF form to
997 internal ELF form, and then using the information to create a
998 canonical bfd symbol table entry.
1000 Note that we allocate the initial bfd canonical symbol buffer
1001 based on a one-to-one mapping of the ELF symbols to canonical
1002 symbols. We actually use all the ELF symbols, so there will be no
1003 space left over at the end. When we have all the symbols, we
1004 build the caller's pointer vector. */
1008 hdr = &elf_tdata (abfd)->symtab_hdr;
1013 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1014 if (elf_dynversym (abfd) == 0)
1017 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1018 if ((elf_tdata (abfd)->dynverdef_section != 0
1019 && elf_tdata (abfd)->verdef == NULL)
1020 || (elf_tdata (abfd)->dynverref_section != 0
1021 && elf_tdata (abfd)->verref == NULL))
1023 if (! _bfd_elf_slurp_version_tables (abfd))
1028 ebd = get_elf_backend_data (abfd);
1029 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1031 sym = symbase = NULL;
1034 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1036 if (isymbuf == NULL)
1040 amt *= sizeof (elf_symbol_type);
1041 symbase = bfd_zalloc (abfd, amt);
1042 if (symbase == (elf_symbol_type *) NULL)
1045 /* Read the raw ELF version symbol information. */
1047 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1049 (*_bfd_error_handler)
1050 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1052 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1055 /* Slurp in the symbols without the version information,
1056 since that is more helpful than just quitting. */
1062 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1065 xverbuf = bfd_malloc (verhdr->sh_size);
1066 if (xverbuf == NULL && verhdr->sh_size != 0)
1069 if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1073 /* Skip first symbol, which is a null dummy. */
1077 isymend = isymbuf + symcount;
1078 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1080 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1081 sym->symbol.the_bfd = abfd;
1083 sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1087 sym->symbol.value = isym->st_value;
1089 if (isym->st_shndx == SHN_UNDEF)
1091 sym->symbol.section = bfd_und_section_ptr;
1093 else if (isym->st_shndx < SHN_LORESERVE
1094 || isym->st_shndx > SHN_HIRESERVE)
1096 sym->symbol.section = bfd_section_from_elf_index (abfd,
1098 if (sym->symbol.section == NULL)
1100 /* This symbol is in a section for which we did not
1101 create a BFD section. Just use bfd_abs_section,
1102 although it is wrong. FIXME. */
1103 sym->symbol.section = bfd_abs_section_ptr;
1106 else if (isym->st_shndx == SHN_ABS)
1108 sym->symbol.section = bfd_abs_section_ptr;
1110 else if (isym->st_shndx == SHN_COMMON)
1112 sym->symbol.section = bfd_com_section_ptr;
1113 /* Elf puts the alignment into the `value' field, and
1114 the size into the `size' field. BFD wants to see the
1115 size in the value field, and doesn't care (at the
1116 moment) about the alignment. */
1117 sym->symbol.value = isym->st_size;
1120 sym->symbol.section = bfd_abs_section_ptr;
1122 /* If this is a relocatable file, then the symbol value is
1123 already section relative. */
1124 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1125 sym->symbol.value -= sym->symbol.section->vma;
1127 switch (ELF_ST_BIND (isym->st_info))
1130 sym->symbol.flags |= BSF_LOCAL;
1133 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1134 sym->symbol.flags |= BSF_GLOBAL;
1137 sym->symbol.flags |= BSF_WEAK;
1141 switch (ELF_ST_TYPE (isym->st_info))
1144 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1147 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1150 sym->symbol.flags |= BSF_FUNCTION;
1153 sym->symbol.flags |= BSF_OBJECT;
1158 sym->symbol.flags |= BSF_DYNAMIC;
1162 Elf_Internal_Versym iversym;
1164 _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1165 sym->version = iversym.vs_vers;
1169 /* Do some backend-specific processing on this symbol. */
1170 if (ebd->elf_backend_symbol_processing)
1171 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1175 /* Do some backend-specific processing on this symbol table. */
1176 if (ebd->elf_backend_symbol_table_processing)
1177 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1179 /* We rely on the zalloc to clear out the final symbol entry. */
1181 symcount = sym - symbase;
1183 /* Fill in the user's symbol pointer vector if needed. */
1191 *symptrs++ = &sym->symbol;
1194 *symptrs = 0; /* Final null pointer */
1197 if (xverbuf != NULL)
1199 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1204 if (xverbuf != NULL)
1206 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1211 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1215 elf_slurp_reloc_table_from_section (bfd *abfd,
1217 Elf_Internal_Shdr *rel_hdr,
1218 bfd_size_type reloc_count,
1221 bfd_boolean dynamic)
1223 const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1224 void *allocated = NULL;
1225 bfd_byte *native_relocs;
1229 unsigned int symcount;
1231 allocated = bfd_malloc (rel_hdr->sh_size);
1232 if (allocated == NULL)
1235 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1236 || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1237 != rel_hdr->sh_size))
1240 native_relocs = allocated;
1242 entsize = rel_hdr->sh_entsize;
1243 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1244 || entsize == sizeof (Elf_External_Rela));
1247 symcount = bfd_get_dynamic_symcount (abfd);
1249 symcount = bfd_get_symcount (abfd);
1251 for (i = 0, relent = relents;
1253 i++, relent++, native_relocs += entsize)
1255 Elf_Internal_Rela rela;
1257 if (entsize == sizeof (Elf_External_Rela))
1258 elf_swap_reloca_in (abfd, native_relocs, &rela);
1260 elf_swap_reloc_in (abfd, native_relocs, &rela);
1262 /* The address of an ELF reloc is section relative for an object
1263 file, and absolute for an executable file or shared library.
1264 The address of a normal BFD reloc is always section relative,
1265 and the address of a dynamic reloc is absolute.. */
1266 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1267 relent->address = rela.r_offset;
1269 relent->address = rela.r_offset - asect->vma;
1271 if (ELF_R_SYM (rela.r_info) == 0)
1272 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1273 else if (ELF_R_SYM (rela.r_info) > symcount)
1275 (*_bfd_error_handler)
1276 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1277 abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1278 relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1284 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1287 /* Canonicalize ELF section symbols. FIXME: Why? */
1288 if ((s->flags & BSF_SECTION_SYM) == 0)
1289 relent->sym_ptr_ptr = ps;
1291 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1294 relent->addend = rela.r_addend;
1296 if ((entsize == sizeof (Elf_External_Rela)
1297 && ebd->elf_info_to_howto != NULL)
1298 || ebd->elf_info_to_howto_rel == NULL)
1299 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1301 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1304 if (allocated != NULL)
1310 if (allocated != NULL)
1315 /* Read in and swap the external relocs. */
1318 elf_slurp_reloc_table (bfd *abfd,
1321 bfd_boolean dynamic)
1323 struct bfd_elf_section_data * const d = elf_section_data (asect);
1324 Elf_Internal_Shdr *rel_hdr;
1325 Elf_Internal_Shdr *rel_hdr2;
1326 bfd_size_type reloc_count;
1327 bfd_size_type reloc_count2;
1331 if (asect->relocation != NULL)
1336 if ((asect->flags & SEC_RELOC) == 0
1337 || asect->reloc_count == 0)
1340 rel_hdr = &d->rel_hdr;
1341 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1342 rel_hdr2 = d->rel_hdr2;
1343 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1345 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1346 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1347 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1352 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1353 case because relocations against this section may use the
1354 dynamic symbol table, and in that case bfd_section_from_shdr
1355 in elf.c does not update the RELOC_COUNT. */
1356 if (asect->_raw_size == 0)
1359 rel_hdr = &d->this_hdr;
1360 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1365 amt = (reloc_count + reloc_count2) * sizeof (arelent);
1366 relents = bfd_alloc (abfd, amt);
1367 if (relents == NULL)
1370 if (!elf_slurp_reloc_table_from_section (abfd, asect,
1371 rel_hdr, reloc_count,
1377 && !elf_slurp_reloc_table_from_section (abfd, asect,
1378 rel_hdr2, reloc_count2,
1379 relents + reloc_count,
1383 asect->relocation = relents;
1389 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1391 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1392 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1395 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1396 (long) hdr->sh_name,
1397 (long) hdr->sh_type,
1398 (long) hdr->sh_flags);
1400 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1401 (long) hdr->sh_addr,
1402 (long) hdr->sh_offset,
1403 (long) hdr->sh_size);
1405 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1406 (long) hdr->sh_link,
1407 (long) hdr->sh_info,
1408 (long) hdr->sh_addralign);
1409 fprintf (stderr, "sh_entsize = %ld\n",
1410 (long) hdr->sh_entsize);
1415 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1417 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1418 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1419 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1420 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1421 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1422 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1423 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1427 elf_symbol_flags (flagword flags)
1429 static char buffer[1024];
1432 if (flags & BSF_LOCAL)
1433 strcat (buffer, " local");
1435 if (flags & BSF_GLOBAL)
1436 strcat (buffer, " global");
1438 if (flags & BSF_DEBUGGING)
1439 strcat (buffer, " debug");
1441 if (flags & BSF_FUNCTION)
1442 strcat (buffer, " function");
1444 if (flags & BSF_KEEP)
1445 strcat (buffer, " keep");
1447 if (flags & BSF_KEEP_G)
1448 strcat (buffer, " keep_g");
1450 if (flags & BSF_WEAK)
1451 strcat (buffer, " weak");
1453 if (flags & BSF_SECTION_SYM)
1454 strcat (buffer, " section-sym");
1456 if (flags & BSF_OLD_COMMON)
1457 strcat (buffer, " old-common");
1459 if (flags & BSF_NOT_AT_END)
1460 strcat (buffer, " not-at-end");
1462 if (flags & BSF_CONSTRUCTOR)
1463 strcat (buffer, " constructor");
1465 if (flags & BSF_WARNING)
1466 strcat (buffer, " warning");
1468 if (flags & BSF_INDIRECT)
1469 strcat (buffer, " indirect");
1471 if (flags & BSF_FILE)
1472 strcat (buffer, " file");
1474 if (flags & DYNAMIC)
1475 strcat (buffer, " dynamic");
1477 if (flags & ~(BSF_LOCAL
1492 strcat (buffer, " unknown-bits");
1498 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1499 reconstruct an ELF file by reading the segments out of remote memory
1500 based on the ELF file header at EHDR_VMA and the ELF program headers it
1501 points to. If not null, *LOADBASEP is filled in with the difference
1502 between the VMAs from which the segments were read, and the VMAs the
1503 file headers (and hence BFD's idea of each section's VMA) put them at.
1505 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1506 remote memory at target address VMA into the local buffer at MYADDR; it
1507 should return zero on success or an `errno' code on failure. TEMPL must
1508 be a BFD for a target with the word size and byte order found in the
1512 NAME(_bfd_elf,bfd_from_remote_memory)
1516 int (*target_read_memory) (bfd_vma, char *, int))
1518 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1519 Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form */
1520 Elf_External_Phdr *x_phdrs;
1521 Elf_Internal_Phdr *i_phdrs, *last_phdr;
1523 struct bfd_in_memory *bim;
1530 /* Read in the ELF header in external format. */
1531 err = target_read_memory (ehdr_vma, (char *) &x_ehdr, sizeof x_ehdr);
1534 bfd_set_error (bfd_error_system_call);
1539 /* Now check to see if we have a valid ELF file, and one that BFD can
1540 make use of. The magic number must match, the address size ('class')
1541 and byte-swapping must match our XVEC entry. */
1543 if (! elf_file_p (&x_ehdr)
1544 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1545 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1547 bfd_set_error (bfd_error_wrong_format);
1551 /* Check that file's byte order matches xvec's */
1552 switch (x_ehdr.e_ident[EI_DATA])
1554 case ELFDATA2MSB: /* Big-endian */
1555 if (! bfd_header_big_endian (templ))
1557 bfd_set_error (bfd_error_wrong_format);
1561 case ELFDATA2LSB: /* Little-endian */
1562 if (! bfd_header_little_endian (templ))
1564 bfd_set_error (bfd_error_wrong_format);
1568 case ELFDATANONE: /* No data encoding specified */
1569 default: /* Unknown data encoding specified */
1570 bfd_set_error (bfd_error_wrong_format);
1574 elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1576 /* The file header tells where to find the program headers.
1577 These are what we use to actually choose what to read. */
1579 if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1581 bfd_set_error (bfd_error_wrong_format);
1585 x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1586 if (x_phdrs == NULL)
1588 bfd_set_error (bfd_error_no_memory);
1591 err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (char *) x_phdrs,
1592 i_ehdr.e_phnum * sizeof x_phdrs[0]);
1596 bfd_set_error (bfd_error_system_call);
1600 i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1604 loadbase = ehdr_vma;
1605 for (i = 0; i < i_ehdr.e_phnum; ++i)
1607 elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1608 if (i_phdrs[i].p_type == PT_LOAD)
1610 bfd_vma segment_end;
1611 segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1612 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1613 if (segment_end > (bfd_vma) contents_size)
1614 contents_size = segment_end;
1616 if ((i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1617 loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1619 last_phdr = &i_phdrs[i];
1622 if (last_phdr == NULL)
1624 /* There were no PT_LOAD segments, so we don't have anything to read. */
1626 bfd_set_error (bfd_error_wrong_format);
1630 /* Trim the last segment so we don't bother with zeros in the last page
1631 that are off the end of the file. However, if the extra bit in that
1632 page includes the section headers, keep them. */
1633 if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1634 && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1635 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1637 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1638 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1639 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1640 contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1643 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1645 /* Now we know the size of the whole image we want read in. */
1646 contents = bfd_zmalloc (contents_size);
1647 if (contents == NULL)
1650 bfd_set_error (bfd_error_no_memory);
1654 for (i = 0; i < i_ehdr.e_phnum; ++i)
1655 if (i_phdrs[i].p_type == PT_LOAD)
1657 bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1658 bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1659 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1660 if (end > (bfd_vma) contents_size)
1661 end = contents_size;
1662 err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1663 & -i_phdrs[i].p_align,
1664 contents + start, end - start);
1669 bfd_set_error (bfd_error_system_call);
1676 /* If the segments visible in memory didn't include the section headers,
1677 then clear them from the file header. */
1678 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1679 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1681 memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1682 memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1683 memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1686 /* This will normally have been in the first PT_LOAD segment. But it
1687 conceivably could be missing, and we might have just changed it. */
1688 memcpy (contents, &x_ehdr, sizeof x_ehdr);
1690 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1691 bim = bfd_malloc (sizeof (struct bfd_in_memory));
1695 bfd_set_error (bfd_error_no_memory);
1698 nbfd = _bfd_new_bfd ();
1703 bfd_set_error (bfd_error_no_memory);
1706 nbfd->filename = "<in-memory>";
1707 nbfd->xvec = templ->xvec;
1708 bim->size = contents_size;
1709 bim->buffer = contents;
1710 nbfd->iostream = bim;
1711 nbfd->flags = BFD_IN_MEMORY;
1712 nbfd->direction = read_direction;
1713 nbfd->mtime = time (NULL);
1714 nbfd->mtime_set = TRUE;
1717 *loadbasep = loadbase;
1721 #include "elfcore.h"
1723 /* Size-dependent data and functions. */
1724 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1725 sizeof (Elf_External_Ehdr),
1726 sizeof (Elf_External_Phdr),
1727 sizeof (Elf_External_Shdr),
1728 sizeof (Elf_External_Rel),
1729 sizeof (Elf_External_Rela),
1730 sizeof (Elf_External_Sym),
1731 sizeof (Elf_External_Dyn),
1732 sizeof (Elf_External_Note),
1735 ARCH_SIZE, LOG_FILE_ALIGN,
1736 ELFCLASS, EV_CURRENT,
1737 elf_write_out_phdrs,
1738 elf_write_shdrs_and_ehdr,
1741 elf_swap_symbol_out,
1742 elf_slurp_reloc_table,
1743 elf_slurp_symbol_table,