1 /* ELF executable support for BFD.
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 3 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
31 MA 02110-1301, USA. */
34 /* Problems and other issues to resolve.
36 (1) BFD expects there to be some fixed number of "sections" in
37 the object file. I.E. there is a "section_count" variable in the
38 bfd structure which contains the number of sections. However, ELF
39 supports multiple "views" of a file. In particular, with current
40 implementations, executable files typically have two tables, a
41 program header table and a section header table, both of which
42 partition the executable.
44 In ELF-speak, the "linking view" of the file uses the section header
45 table to access "sections" within the file, and the "execution view"
46 uses the program header table to access "segments" within the file.
47 "Segments" typically may contain all the data from one or more
50 Note that the section header table is optional in ELF executables,
51 but it is this information that is most useful to gdb. If the
52 section header table is missing, then gdb should probably try
53 to make do with the program header table. (FIXME)
55 (2) The code in this file is compiled twice, once in 32-bit mode and
56 once in 64-bit mode. More of it should be made size-independent
59 (3) ELF section symbols are handled rather sloppily now. This should
60 be cleaned up, and ELF section symbols reconciled with BFD section
63 (4) We need a published spec for 64-bit ELF. We've got some stuff here
64 that we're using for SPARC V9 64-bit chips, but don't assume that
70 #include "libiberty.h"
74 #include "libiberty.h"
76 /* Renaming structures, typedefs, macros and functions to be size-specific. */
77 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
78 #define Elf_External_Sym NAME(Elf,External_Sym)
79 #define Elf_External_Shdr NAME(Elf,External_Shdr)
80 #define Elf_External_Phdr NAME(Elf,External_Phdr)
81 #define Elf_External_Rel NAME(Elf,External_Rel)
82 #define Elf_External_Rela NAME(Elf,External_Rela)
83 #define Elf_External_Dyn NAME(Elf,External_Dyn)
85 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
86 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
87 #define elf_core_file_matches_executable_p \
88 NAME(bfd_elf,core_file_matches_executable_p)
89 #define elf_core_file_pid NAME(bfd_elf,core_file_pid)
90 #define elf_object_p NAME(bfd_elf,object_p)
91 #define elf_core_file_p NAME(bfd_elf,core_file_p)
92 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
93 #define elf_get_dynamic_symtab_upper_bound \
94 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
95 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
96 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
97 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
98 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
99 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
100 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
101 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
102 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
103 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
104 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
105 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
106 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
107 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
108 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
109 #define elf_canonicalize_dynamic_symtab \
110 NAME(bfd_elf,canonicalize_dynamic_symtab)
111 #define elf_get_synthetic_symtab \
112 NAME(bfd_elf,get_synthetic_symtab)
113 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
114 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
115 #define elf_get_lineno NAME(bfd_elf,get_lineno)
116 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
117 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
118 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
119 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
120 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
121 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
122 #define elf_find_section NAME(bfd_elf,find_section)
123 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
124 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
125 #define elf_checksum_contents NAME(bfd_elf,checksum_contents)
126 #define elf_write_relocs NAME(bfd_elf,write_relocs)
127 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
130 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
131 #define ELF_R_SYM(X) ELF64_R_SYM(X)
132 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
133 #define ELFCLASS ELFCLASS64
135 #define LOG_FILE_ALIGN 3
138 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
139 #define ELF_R_SYM(X) ELF32_R_SYM(X)
140 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
141 #define ELFCLASS ELFCLASS32
143 #define LOG_FILE_ALIGN 2
147 static void elf_debug_section (int, Elf_Internal_Shdr
*);
150 static void elf_debug_file (Elf_Internal_Ehdr
*);
153 /* Structure swapping routines */
155 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
156 can be handled by explicitly specifying 32 bits or "the long type". */
158 #define H_PUT_WORD H_PUT_64
159 #define H_PUT_SIGNED_WORD H_PUT_S64
160 #define H_GET_WORD H_GET_64
161 #define H_GET_SIGNED_WORD H_GET_S64
164 #define H_PUT_WORD H_PUT_32
165 #define H_PUT_SIGNED_WORD H_PUT_S32
166 #define H_GET_WORD H_GET_32
167 #define H_GET_SIGNED_WORD H_GET_S32
170 /* Translate an ELF symbol in external format into an ELF symbol in internal
174 elf_swap_symbol_in (bfd
*abfd
,
177 Elf_Internal_Sym
*dst
)
179 const Elf_External_Sym
*src
= (const Elf_External_Sym
*) psrc
;
180 const Elf_External_Sym_Shndx
*shndx
= (const Elf_External_Sym_Shndx
*) pshn
;
181 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
183 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
185 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
187 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
188 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
189 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
190 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
191 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
192 if (dst
->st_shndx
== (SHN_XINDEX
& 0xffff))
196 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
198 else if (dst
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
199 dst
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
200 dst
->st_target_internal
= 0;
204 /* Translate an ELF symbol in internal format into an ELF symbol in external
208 elf_swap_symbol_out (bfd
*abfd
,
209 const Elf_Internal_Sym
*src
,
214 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
215 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
216 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
217 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
218 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
219 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
221 if (tmp
>= (SHN_LORESERVE
& 0xffff) && tmp
< SHN_LORESERVE
)
225 H_PUT_32 (abfd
, tmp
, shndx
);
226 tmp
= SHN_XINDEX
& 0xffff;
228 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
231 /* Translate an ELF file header in external format into an ELF file header in
235 elf_swap_ehdr_in (bfd
*abfd
,
236 const Elf_External_Ehdr
*src
,
237 Elf_Internal_Ehdr
*dst
)
239 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
240 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
241 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
242 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
243 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
245 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
247 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
248 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
249 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
250 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
251 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
252 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
253 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
254 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
255 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
256 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
259 /* Translate an ELF file header in internal format into an ELF file header in
263 elf_swap_ehdr_out (bfd
*abfd
,
264 const Elf_Internal_Ehdr
*src
,
265 Elf_External_Ehdr
*dst
)
268 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
269 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
270 /* note that all elements of dst are *arrays of unsigned char* already... */
271 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
272 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
273 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
275 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
277 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
278 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
279 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
280 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
281 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
282 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
286 H_PUT_16 (abfd
, tmp
, dst
->e_phnum
);
287 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
289 if (tmp
>= (SHN_LORESERVE
& 0xffff))
291 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
292 tmp
= src
->e_shstrndx
;
293 if (tmp
>= (SHN_LORESERVE
& 0xffff))
294 tmp
= SHN_XINDEX
& 0xffff;
295 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
298 /* Translate an ELF section header table entry in external format into an
299 ELF section header table entry in internal format. */
302 elf_swap_shdr_in (bfd
*abfd
,
303 const Elf_External_Shdr
*src
,
304 Elf_Internal_Shdr
*dst
)
306 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
308 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
309 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
310 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
312 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
314 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
315 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
316 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
317 /* PR 23657. Check for invalid section size, in sections with contents.
318 Note - we do not set an error value here because the contents
319 of this particular section might not be needed by the consumer. */
320 if (dst
->sh_type
!= SHT_NOBITS
)
322 ufile_ptr filesize
= bfd_get_file_size (abfd
);
325 && ((ufile_ptr
) dst
->sh_offset
> filesize
326 || dst
->sh_size
> filesize
- dst
->sh_offset
))
329 _bfd_error_handler (_("warning: %pB has a section "
330 "extending past end of file"), abfd
);
333 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
334 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
335 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
336 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
337 dst
->bfd_section
= NULL
;
338 dst
->contents
= NULL
;
341 /* Translate an ELF section header table entry in internal format into an
342 ELF section header table entry in external format. */
345 elf_swap_shdr_out (bfd
*abfd
,
346 const Elf_Internal_Shdr
*src
,
347 Elf_External_Shdr
*dst
)
349 /* note that all elements of dst are *arrays of unsigned char* already... */
350 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
351 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
352 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
353 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
354 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
355 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
356 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
357 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
358 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
359 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
362 /* Translate an ELF program header table entry in external format into an
363 ELF program header table entry in internal format. */
366 elf_swap_phdr_in (bfd
*abfd
,
367 const Elf_External_Phdr
*src
,
368 Elf_Internal_Phdr
*dst
)
370 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
372 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
373 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
374 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
377 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
378 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
382 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
383 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
385 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
386 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
387 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
391 elf_swap_phdr_out (bfd
*abfd
,
392 const Elf_Internal_Phdr
*src
,
393 Elf_External_Phdr
*dst
)
395 const struct elf_backend_data
*bed
;
398 bed
= get_elf_backend_data (abfd
);
399 p_paddr
= bed
->want_p_paddr_set_to_zero
? 0 : src
->p_paddr
;
401 /* note that all elements of dst are *arrays of unsigned char* already... */
402 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
403 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
404 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
405 H_PUT_WORD (abfd
, p_paddr
, dst
->p_paddr
);
406 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
407 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
408 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
409 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
412 /* Translate an ELF reloc from external format to internal format. */
414 elf_swap_reloc_in (bfd
*abfd
,
416 Elf_Internal_Rela
*dst
)
418 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
419 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
420 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
425 elf_swap_reloca_in (bfd
*abfd
,
427 Elf_Internal_Rela
*dst
)
429 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
430 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
431 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
432 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
435 /* Translate an ELF reloc from internal format to external format. */
437 elf_swap_reloc_out (bfd
*abfd
,
438 const Elf_Internal_Rela
*src
,
441 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
442 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
443 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
447 elf_swap_reloca_out (bfd
*abfd
,
448 const Elf_Internal_Rela
*src
,
451 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
452 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
453 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
454 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
458 elf_swap_dyn_in (bfd
*abfd
,
460 Elf_Internal_Dyn
*dst
)
462 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
464 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
465 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
469 elf_swap_dyn_out (bfd
*abfd
,
470 const Elf_Internal_Dyn
*src
,
473 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
475 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
476 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
479 /* ELF .o/exec file reading */
481 /* Begin processing a given object.
483 First we validate the file by reading in the ELF header and checking
486 static inline bfd_boolean
487 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
489 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
490 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
491 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
492 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
495 /* Check to see if the file associated with ABFD matches the target vector
498 Note that we may be called several times with the same ABFD, but different
499 target vectors, most of which will not match. We have to avoid leaving
500 any side effects in ABFD, or any data it points to (like tdata), if the
501 file does not match the target vector. */
504 elf_object_p (bfd
*abfd
)
506 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
507 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
508 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
509 Elf_Internal_Shdr i_shdr
;
510 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
511 unsigned int shindex
;
512 const struct elf_backend_data
*ebd
;
514 const bfd_target
*target
;
516 /* Read in the ELF header in external format. */
518 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
520 if (bfd_get_error () != bfd_error_system_call
)
521 goto got_wrong_format_error
;
526 /* Now check to see if we have a valid ELF file, and one that BFD can
527 make use of. The magic number must match, the address size ('class')
528 and byte-swapping must match our XVEC entry, and it must have a
529 section header table (FIXME: See comments re sections at top of this
532 if (! elf_file_p (&x_ehdr
)
533 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
534 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
535 goto got_wrong_format_error
;
537 /* Check that file's byte order matches xvec's */
538 switch (x_ehdr
.e_ident
[EI_DATA
])
540 case ELFDATA2MSB
: /* Big-endian */
541 if (! bfd_header_big_endian (abfd
))
542 goto got_wrong_format_error
;
544 case ELFDATA2LSB
: /* Little-endian */
545 if (! bfd_header_little_endian (abfd
))
546 goto got_wrong_format_error
;
548 case ELFDATANONE
: /* No data encoding specified */
549 default: /* Unknown data encoding specified */
550 goto got_wrong_format_error
;
555 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
556 the tdata pointer in the bfd. */
558 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
561 /* Now that we know the byte order, swap in the rest of the header */
562 i_ehdrp
= elf_elfheader (abfd
);
563 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
565 elf_debug_file (i_ehdrp
);
568 /* Reject ET_CORE (header indicates core file, not object file) */
569 if (i_ehdrp
->e_type
== ET_CORE
)
570 goto got_wrong_format_error
;
572 /* If this is a relocatable file and there is no section header
573 table, then we're hosed. */
574 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
575 goto got_wrong_format_error
;
577 /* As a simple sanity check, verify that what BFD thinks is the
578 size of each section header table entry actually matches the size
579 recorded in the file, but only if there are any sections. */
580 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
581 goto got_wrong_format_error
;
583 /* Further sanity check. */
584 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
585 goto got_wrong_format_error
;
587 ebd
= get_elf_backend_data (abfd
);
588 if (ebd
->s
->arch_size
!= ARCH_SIZE
)
589 goto got_wrong_format_error
;
591 /* Check that the ELF e_machine field matches what this particular
592 BFD format expects. */
593 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
594 && (ebd
->elf_machine_alt1
== 0
595 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
596 && (ebd
->elf_machine_alt2
== 0
597 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
)
598 && ebd
->elf_machine_code
!= EM_NONE
)
599 goto got_wrong_format_error
;
601 if (i_ehdrp
->e_type
== ET_EXEC
)
602 abfd
->flags
|= EXEC_P
;
603 else if (i_ehdrp
->e_type
== ET_DYN
)
604 abfd
->flags
|= DYNAMIC
;
606 if (i_ehdrp
->e_phnum
> 0)
607 abfd
->flags
|= D_PAGED
;
609 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
611 /* It's OK if this fails for the generic target. */
612 if (ebd
->elf_machine_code
!= EM_NONE
)
616 if (ebd
->elf_machine_code
!= EM_NONE
617 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
618 && ebd
->elf_osabi
!= ELFOSABI_NONE
)
619 goto got_wrong_format_error
;
621 if (i_ehdrp
->e_shoff
!= 0)
623 file_ptr where
= (file_ptr
) i_ehdrp
->e_shoff
;
625 /* Seek to the section header table in the file. */
626 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
629 /* Read the first section header at index 0, and convert to internal
631 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
633 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
635 /* If the section count is zero, the actual count is in the first
637 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
639 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
640 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
641 || i_ehdrp
->e_shnum
!= i_shdr
.sh_size
642 || i_ehdrp
->e_shnum
== 0)
643 goto got_wrong_format_error
;
646 /* And similarly for the string table index. */
647 if (i_ehdrp
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
649 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
650 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
651 goto got_wrong_format_error
;
654 /* And program headers. */
655 if (i_ehdrp
->e_phnum
== PN_XNUM
&& i_shdr
.sh_info
!= 0)
657 i_ehdrp
->e_phnum
= i_shdr
.sh_info
;
658 if (i_ehdrp
->e_phnum
!= i_shdr
.sh_info
)
659 goto got_wrong_format_error
;
662 /* Sanity check that we can read all of the section headers.
663 It ought to be good enough to just read the last one. */
664 if (i_ehdrp
->e_shnum
!= 1)
666 /* Check that we don't have a totally silly number of sections. */
667 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
668 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
669 goto got_wrong_format_error
;
671 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
672 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
673 goto got_wrong_format_error
;
675 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
677 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
680 /* Back to where we were. */
681 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
682 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
687 /* Allocate space for a copy of the section header table in
689 if (i_ehdrp
->e_shnum
!= 0)
691 Elf_Internal_Shdr
*shdrp
;
692 unsigned int num_sec
;
695 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*i_shdrp
), &amt
))
696 goto got_wrong_format_error
;
697 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
700 num_sec
= i_ehdrp
->e_shnum
;
701 elf_numsections (abfd
) = num_sec
;
702 if (_bfd_mul_overflow (num_sec
, sizeof (i_shdrp
), &amt
))
703 goto got_wrong_format_error
;
704 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
705 if (!elf_elfsections (abfd
))
708 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
709 for (shdrp
= i_shdrp
, shindex
= 0; shindex
< num_sec
; shindex
++)
710 elf_elfsections (abfd
)[shindex
] = shdrp
++;
712 /* Read in the rest of the section header table and convert it
714 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
716 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
718 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
720 /* Sanity check sh_link and sh_info. */
721 if (i_shdrp
[shindex
].sh_link
>= num_sec
)
723 /* PR 10478: Accept Solaris binaries with a sh_link
724 field set to SHN_BEFORE or SHN_AFTER. */
725 switch (ebd
->elf_machine_code
)
734 if (i_shdrp
[shindex
].sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
735 || i_shdrp
[shindex
].sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
737 /* Otherwise fall through. */
739 goto got_wrong_format_error
;
743 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
744 || i_shdrp
[shindex
].sh_type
== SHT_RELA
745 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
746 && i_shdrp
[shindex
].sh_info
>= num_sec
)
747 goto got_wrong_format_error
;
749 /* If the section is loaded, but not page aligned, clear
751 if (i_shdrp
[shindex
].sh_size
!= 0
752 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
753 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
754 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
757 abfd
->flags
&= ~D_PAGED
;
760 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
)
761 || i_shdrp
[i_ehdrp
->e_shstrndx
].sh_type
!= SHT_STRTAB
)
764 We used to just goto got_wrong_format_error here
765 but there are binaries in existance for which this test
766 will prevent the binutils from working with them at all.
767 So we are kind, and reset the string index value to 0
768 so that at least some processing can be done. */
769 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
772 (_("warning: %pB has a corrupt string table index - ignoring"),
776 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
777 goto got_wrong_format_error
;
779 /* Read in the program headers. */
780 if (i_ehdrp
->e_phnum
== 0)
781 elf_tdata (abfd
)->phdr
= NULL
;
784 Elf_Internal_Phdr
*i_phdr
;
789 /* Check for a corrupt input file with an impossibly large number
790 of program headers. */
791 filesize
= bfd_get_file_size (abfd
);
793 && i_ehdrp
->e_phnum
> filesize
/ sizeof (Elf_External_Phdr
))
794 goto got_wrong_format_error
;
795 if (_bfd_mul_overflow (i_ehdrp
->e_phnum
, sizeof (*i_phdr
), &amt
))
796 goto got_wrong_format_error
;
797 elf_tdata (abfd
)->phdr
798 = (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
799 if (elf_tdata (abfd
)->phdr
== NULL
)
801 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
803 i_phdr
= elf_tdata (abfd
)->phdr
;
804 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
806 Elf_External_Phdr x_phdr
;
808 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
810 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
811 /* Too much code in BFD relies on alignment being a power of
812 two, as required by the ELF spec. */
813 if (i_phdr
->p_align
!= (i_phdr
->p_align
& -i_phdr
->p_align
))
816 _bfd_error_handler (_("warning: %pB has a program header "
817 "with invalid alignment"), abfd
);
822 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
824 unsigned int num_sec
;
826 /* Once all of the section headers have been read and converted, we
827 can start processing them. Note that the first section header is
828 a dummy placeholder entry, so we ignore it. */
829 num_sec
= elf_numsections (abfd
);
830 for (shindex
= 1; shindex
< num_sec
; shindex
++)
831 if (!bfd_section_from_shdr (abfd
, shindex
))
834 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
835 if (! _bfd_elf_setup_sections (abfd
))
836 goto got_wrong_format_error
;
839 /* Let the backend double check the format and override global
841 if (ebd
->elf_backend_object_p
)
843 if (! (*ebd
->elf_backend_object_p
) (abfd
))
844 goto got_wrong_format_error
;
847 /* Remember the entry point specified in the ELF file header. */
848 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
850 /* If we have created any reloc sections that are associated with
851 debugging sections, mark the reloc sections as debugging as well. */
852 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
854 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
855 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
856 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
858 unsigned long targ_index
;
861 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
862 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
864 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
865 s
->flags
|= SEC_DEBUGGING
;
868 return _bfd_no_cleanup
;
870 got_wrong_format_error
:
871 bfd_set_error (bfd_error_wrong_format
);
877 /* ELF .o/exec file writing */
879 /* Write out the relocs. */
882 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
884 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
885 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
886 Elf_Internal_Shdr
*rela_hdr
;
888 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
896 /* If we have already failed, don't do anything. */
900 if ((sec
->flags
& SEC_RELOC
) == 0)
903 /* The linker backend writes the relocs out itself, and sets the
904 reloc_count field to zero to inhibit writing them here. Also,
905 sometimes the SEC_RELOC flag gets set even when there aren't any
907 if (sec
->reloc_count
== 0)
910 /* If we have opened an existing file for update, reloc_count may be
911 set even though we are not linking. In that case we have nothing
913 if (sec
->orelocation
== NULL
)
916 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
917 if (rela_hdr
== NULL
)
918 rela_hdr
= elf_section_data (sec
)->rel
.hdr
;
920 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
921 if (_bfd_mul_overflow (sec
->reloc_count
, rela_hdr
->sh_entsize
, &amt
)
922 || (rela_hdr
->contents
= bfd_alloc (abfd
, amt
)) == NULL
)
924 bfd_set_error (bfd_error_no_memory
);
929 /* Figure out whether the relocations are RELA or REL relocations. */
930 if (rela_hdr
->sh_type
== SHT_RELA
)
932 swap_out
= elf_swap_reloca_out
;
933 extsize
= sizeof (Elf_External_Rela
);
935 else if (rela_hdr
->sh_type
== SHT_REL
)
937 swap_out
= elf_swap_reloc_out
;
938 extsize
= sizeof (Elf_External_Rel
);
941 /* Every relocation section should be either an SHT_RELA or an
945 /* The address of an ELF reloc is section relative for an object
946 file, and absolute for an executable file or shared library.
947 The address of a BFD reloc is always section relative. */
949 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
950 addr_offset
= sec
->vma
;
952 /* orelocation has the data, reloc_count has the count... */
955 dst_rela
= rela_hdr
->contents
;
957 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
959 Elf_Internal_Rela src_rela
;
964 ptr
= sec
->orelocation
[idx
];
965 sym
= *ptr
->sym_ptr_ptr
;
968 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
973 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
982 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
983 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
984 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
990 if (ptr
->howto
== NULL
)
996 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
997 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
998 src_rela
.r_addend
= ptr
->addend
;
999 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
1002 if (!bed
->write_secondary_relocs (abfd
, sec
))
1009 /* Write out the program headers. */
1012 elf_write_out_phdrs (bfd
*abfd
,
1013 const Elf_Internal_Phdr
*phdr
,
1018 Elf_External_Phdr extphdr
;
1020 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1021 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
1022 != sizeof (Elf_External_Phdr
))
1029 /* Write out the section headers and the ELF file header. */
1032 elf_write_shdrs_and_ehdr (bfd
*abfd
)
1034 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1035 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1036 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1037 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1041 i_ehdrp
= elf_elfheader (abfd
);
1042 i_shdrp
= elf_elfsections (abfd
);
1044 /* swap the header before spitting it out... */
1047 elf_debug_file (i_ehdrp
);
1049 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1050 amt
= sizeof (x_ehdr
);
1051 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1052 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1055 /* Some fields in the first section header handle overflow of ehdr
1057 if (i_ehdrp
->e_phnum
>= PN_XNUM
)
1058 i_shdrp
[0]->sh_info
= i_ehdrp
->e_phnum
;
1059 if (i_ehdrp
->e_shnum
>= (SHN_LORESERVE
& 0xffff))
1060 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1061 if (i_ehdrp
->e_shstrndx
>= (SHN_LORESERVE
& 0xffff))
1062 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1064 /* at this point we've concocted all the ELF sections... */
1065 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*x_shdrp
), &amt
))
1067 bfd_set_error (bfd_error_no_memory
);
1070 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1074 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1077 elf_debug_section (count
, *i_shdrp
);
1079 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1081 amt
= (bfd_size_type
) i_ehdrp
->e_shnum
* sizeof (*x_shdrp
);
1082 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1083 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1086 /* need to dump the string table too... */
1092 elf_checksum_contents (bfd
*abfd
,
1093 void (*process
) (const void *, size_t, void *),
1096 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1097 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
1098 Elf_Internal_Phdr
*i_phdrp
= elf_tdata (abfd
)->phdr
;
1099 unsigned int count
, num
;
1102 Elf_External_Ehdr x_ehdr
;
1103 Elf_Internal_Ehdr i_ehdr
;
1106 i_ehdr
.e_phoff
= i_ehdr
.e_shoff
= 0;
1107 elf_swap_ehdr_out (abfd
, &i_ehdr
, &x_ehdr
);
1108 (*process
) (&x_ehdr
, sizeof x_ehdr
, arg
);
1111 num
= i_ehdrp
->e_phnum
;
1112 for (count
= 0; count
< num
; count
++)
1114 Elf_External_Phdr x_phdr
;
1115 elf_swap_phdr_out (abfd
, &i_phdrp
[count
], &x_phdr
);
1116 (*process
) (&x_phdr
, sizeof x_phdr
, arg
);
1119 num
= elf_numsections (abfd
);
1120 for (count
= 0; count
< num
; count
++)
1122 Elf_Internal_Shdr i_shdr
;
1123 Elf_External_Shdr x_shdr
;
1124 bfd_byte
*contents
, *free_contents
;
1126 i_shdr
= *i_shdrp
[count
];
1127 i_shdr
.sh_offset
= 0;
1129 elf_swap_shdr_out (abfd
, &i_shdr
, &x_shdr
);
1130 (*process
) (&x_shdr
, sizeof x_shdr
, arg
);
1132 /* Process the section's contents, if it has some.
1133 PR ld/12451: Read them in if necessary. */
1134 if (i_shdr
.sh_type
== SHT_NOBITS
)
1136 free_contents
= NULL
;
1137 contents
= i_shdr
.contents
;
1138 if (contents
== NULL
)
1142 sec
= bfd_section_from_elf_index (abfd
, count
);
1145 contents
= sec
->contents
;
1146 if (contents
== NULL
)
1148 /* Force rereading from file. */
1149 sec
->flags
&= ~SEC_IN_MEMORY
;
1150 if (!bfd_malloc_and_get_section (abfd
, sec
, &free_contents
))
1152 contents
= free_contents
;
1156 if (contents
!= NULL
)
1158 (*process
) (contents
, i_shdr
.sh_size
, arg
);
1159 free (free_contents
);
1167 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
1169 Elf_Internal_Shdr
*hdr
;
1170 Elf_Internal_Shdr
*verhdr
;
1171 unsigned long symcount
; /* Number of external ELF symbols */
1172 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1173 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1174 Elf_Internal_Sym
*isym
;
1175 Elf_Internal_Sym
*isymend
;
1176 Elf_Internal_Sym
*isymbuf
= NULL
;
1177 Elf_External_Versym
*xver
;
1178 Elf_External_Versym
*xverbuf
= NULL
;
1179 const struct elf_backend_data
*ebd
;
1182 /* Read each raw ELF symbol, converting from external ELF form to
1183 internal ELF form, and then using the information to create a
1184 canonical bfd symbol table entry.
1186 Note that we allocate the initial bfd canonical symbol buffer
1187 based on a one-to-one mapping of the ELF symbols to canonical
1188 symbols. We actually use all the ELF symbols, so there will be no
1189 space left over at the end. When we have all the symbols, we
1190 build the caller's pointer vector. */
1194 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1199 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1200 if (elf_dynversym (abfd
) == 0)
1203 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1204 if ((elf_dynverdef (abfd
) != 0
1205 && elf_tdata (abfd
)->verdef
== NULL
)
1206 || (elf_dynverref (abfd
) != 0
1207 && elf_tdata (abfd
)->verref
== NULL
))
1209 if (!_bfd_elf_slurp_version_tables (abfd
, FALSE
))
1214 ebd
= get_elf_backend_data (abfd
);
1215 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1217 sym
= symbase
= NULL
;
1220 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1222 if (isymbuf
== NULL
)
1225 if (_bfd_mul_overflow (symcount
, sizeof (elf_symbol_type
), &amt
))
1227 bfd_set_error (bfd_error_file_too_big
);
1230 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1231 if (symbase
== (elf_symbol_type
*) NULL
)
1234 /* Read the raw ELF version symbol information. */
1236 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1239 /* xgettext:c-format */
1240 (_("%pB: version count (%" PRId64
")"
1241 " does not match symbol count (%ld)"),
1243 (int64_t) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1246 /* Slurp in the symbols without the version information,
1247 since that is more helpful than just quitting. */
1253 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1255 xverbuf
= (Elf_External_Versym
*)
1256 _bfd_malloc_and_read (abfd
, verhdr
->sh_size
, verhdr
->sh_size
);
1257 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1261 /* Skip first symbol, which is a null dummy. */
1265 isymend
= isymbuf
+ symcount
;
1266 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1268 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1270 sym
->symbol
.the_bfd
= abfd
;
1271 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1272 sym
->symbol
.value
= isym
->st_value
;
1274 if (isym
->st_shndx
== SHN_UNDEF
)
1276 sym
->symbol
.section
= bfd_und_section_ptr
;
1278 else if (isym
->st_shndx
== SHN_ABS
)
1280 sym
->symbol
.section
= bfd_abs_section_ptr
;
1282 else if (isym
->st_shndx
== SHN_COMMON
)
1284 sym
->symbol
.section
= bfd_com_section_ptr
;
1285 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
1287 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
1291 flagword flags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
1293 xc
= bfd_make_section_with_flags (abfd
, "COMMON", flags
);
1297 sym
->symbol
.section
= xc
;
1299 /* Elf puts the alignment into the `value' field, and
1300 the size into the `size' field. BFD wants to see the
1301 size in the value field, and doesn't care (at the
1302 moment) about the alignment. */
1303 sym
->symbol
.value
= isym
->st_size
;
1308 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1309 if (sym
->symbol
.section
== NULL
)
1311 /* This symbol is in a section for which we did not
1312 create a BFD section. Just use bfd_abs_section,
1313 although it is wrong. FIXME. Note - there is
1314 code in elf.c:swap_out_syms that calls
1315 symbol_section_index() in the elf backend for
1317 sym
->symbol
.section
= bfd_abs_section_ptr
;
1321 /* If this is a relocatable file, then the symbol value is
1322 already section relative. */
1323 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1324 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1326 switch (ELF_ST_BIND (isym
->st_info
))
1329 sym
->symbol
.flags
|= BSF_LOCAL
;
1332 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1333 sym
->symbol
.flags
|= BSF_GLOBAL
;
1336 sym
->symbol
.flags
|= BSF_WEAK
;
1338 case STB_GNU_UNIQUE
:
1339 sym
->symbol
.flags
|= BSF_GNU_UNIQUE
;
1343 switch (ELF_ST_TYPE (isym
->st_info
))
1346 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1349 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1352 sym
->symbol
.flags
|= BSF_FUNCTION
;
1355 /* FIXME: Do we have to put the size field into the value field
1356 as we do with symbols in SHN_COMMON sections (see above) ? */
1357 sym
->symbol
.flags
|= BSF_ELF_COMMON
;
1360 sym
->symbol
.flags
|= BSF_OBJECT
;
1363 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1366 sym
->symbol
.flags
|= BSF_RELC
;
1369 sym
->symbol
.flags
|= BSF_SRELC
;
1372 sym
->symbol
.flags
|= BSF_GNU_INDIRECT_FUNCTION
;
1377 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1381 Elf_Internal_Versym iversym
;
1383 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1384 sym
->version
= iversym
.vs_vers
;
1388 /* Do some backend-specific processing on this symbol. */
1389 if (ebd
->elf_backend_symbol_processing
)
1390 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1394 /* Do some backend-specific processing on this symbol table. */
1395 if (ebd
->elf_backend_symbol_table_processing
)
1396 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1398 /* We rely on the zalloc to clear out the final symbol entry. */
1400 symcount
= sym
- symbase
;
1402 /* Fill in the user's symbol pointer vector if needed. */
1410 *symptrs
++ = &sym
->symbol
;
1413 *symptrs
= 0; /* Final null pointer */
1417 if (hdr
->contents
!= (unsigned char *) isymbuf
)
1423 if (hdr
->contents
!= (unsigned char *) isymbuf
)
1428 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1432 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1434 Elf_Internal_Shdr
*rel_hdr
,
1435 bfd_size_type reloc_count
,
1438 bfd_boolean dynamic
)
1440 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1441 void *allocated
= NULL
;
1442 bfd_byte
*native_relocs
;
1446 unsigned int symcount
;
1448 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1450 allocated
= _bfd_malloc_and_read (abfd
, rel_hdr
->sh_size
, rel_hdr
->sh_size
);
1451 if (allocated
== NULL
)
1454 native_relocs
= (bfd_byte
*) allocated
;
1456 entsize
= rel_hdr
->sh_entsize
;
1457 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1458 || entsize
== sizeof (Elf_External_Rela
));
1461 symcount
= bfd_get_dynamic_symcount (abfd
);
1463 symcount
= bfd_get_symcount (abfd
);
1465 for (i
= 0, relent
= relents
;
1467 i
++, relent
++, native_relocs
+= entsize
)
1470 Elf_Internal_Rela rela
;
1472 if (entsize
== sizeof (Elf_External_Rela
))
1473 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1475 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1477 /* The address of an ELF reloc is section relative for an object
1478 file, and absolute for an executable file or shared library.
1479 The address of a normal BFD reloc is always section relative,
1480 and the address of a dynamic reloc is absolute.. */
1481 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1482 relent
->address
= rela
.r_offset
;
1484 relent
->address
= rela
.r_offset
- asect
->vma
;
1486 if (ELF_R_SYM (rela
.r_info
) == STN_UNDEF
)
1487 /* FIXME: This and the error case below mean that we have a
1488 symbol on relocs that is not elf_symbol_type. */
1489 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1490 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1493 /* xgettext:c-format */
1494 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
1495 abfd
, asect
, i
, (long) ELF_R_SYM (rela
.r_info
));
1496 bfd_set_error (bfd_error_bad_value
);
1497 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1503 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1505 relent
->sym_ptr_ptr
= ps
;
1508 relent
->addend
= rela
.r_addend
;
1510 if ((entsize
== sizeof (Elf_External_Rela
)
1511 && ebd
->elf_info_to_howto
!= NULL
)
1512 || ebd
->elf_info_to_howto_rel
== NULL
)
1513 res
= ebd
->elf_info_to_howto (abfd
, relent
, &rela
);
1515 res
= ebd
->elf_info_to_howto_rel (abfd
, relent
, &rela
);
1517 if (! res
|| relent
->howto
== NULL
)
1529 /* Read in and swap the external relocs. */
1532 elf_slurp_reloc_table (bfd
*abfd
,
1535 bfd_boolean dynamic
)
1537 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
1538 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1539 Elf_Internal_Shdr
*rel_hdr
;
1540 Elf_Internal_Shdr
*rel_hdr2
;
1541 bfd_size_type reloc_count
;
1542 bfd_size_type reloc_count2
;
1546 if (asect
->relocation
!= NULL
)
1551 if ((asect
->flags
& SEC_RELOC
) == 0
1552 || asect
->reloc_count
== 0)
1555 rel_hdr
= d
->rel
.hdr
;
1556 reloc_count
= rel_hdr
? NUM_SHDR_ENTRIES (rel_hdr
) : 0;
1557 rel_hdr2
= d
->rela
.hdr
;
1558 reloc_count2
= rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0;
1560 /* PR 17512: file: 0b4f81b7. */
1561 if (asect
->reloc_count
!= reloc_count
+ reloc_count2
)
1563 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
1564 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1569 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1570 case because relocations against this section may use the
1571 dynamic symbol table, and in that case bfd_section_from_shdr
1572 in elf.c does not update the RELOC_COUNT. */
1573 if (asect
->size
== 0)
1576 rel_hdr
= &d
->this_hdr
;
1577 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1582 if (_bfd_mul_overflow (reloc_count
+ reloc_count2
, sizeof (arelent
), &amt
))
1584 bfd_set_error (bfd_error_file_too_big
);
1587 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1588 if (relents
== NULL
)
1592 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1593 rel_hdr
, reloc_count
,
1599 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1600 rel_hdr2
, reloc_count2
,
1601 relents
+ reloc_count
,
1605 if (!bed
->slurp_secondary_relocs (abfd
, asect
, symbols
))
1608 asect
->relocation
= relents
;
1614 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1616 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1617 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1620 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1621 (long) hdr
->sh_name
,
1622 (long) hdr
->sh_type
,
1623 (long) hdr
->sh_flags
);
1625 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1626 (long) hdr
->sh_addr
,
1627 (long) hdr
->sh_offset
,
1628 (long) hdr
->sh_size
);
1630 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1631 (long) hdr
->sh_link
,
1632 (long) hdr
->sh_info
,
1633 (long) hdr
->sh_addralign
);
1634 fprintf (stderr
, "sh_entsize = %ld\n",
1635 (long) hdr
->sh_entsize
);
1642 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1644 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1645 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1646 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1647 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1648 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1649 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1650 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1654 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1655 reconstruct an ELF file by reading the segments out of remote
1656 memory based on the ELF file header at EHDR_VMA and the ELF program
1657 headers it points to. If non-zero, SIZE is the known extent of the
1658 object. If not null, *LOADBASEP is filled in with the difference
1659 between the VMAs from which the segments were read, and the VMAs
1660 the file headers (and hence BFD's idea of each section's VMA) put
1663 The function TARGET_READ_MEMORY is called to copy LEN bytes from
1664 the remote memory at target address VMA into the local buffer at
1665 MYADDR; it should return zero on success or an `errno' code on
1666 failure. TEMPL must be a BFD for a target with the word size and
1667 byte order found in the remote memory. */
1670 NAME(_bfd_elf
,bfd_from_remote_memory
)
1672 bfd_vma ehdr_vma
/* Bytes. */,
1673 bfd_size_type size
/* Octets. */,
1674 bfd_vma
*loadbasep
/* Bytes. */,
1675 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
1676 /* (Bytes , , octets ). */
1678 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1679 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1680 Elf_External_Phdr
*x_phdrs
;
1681 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
, *first_phdr
;
1683 struct bfd_in_memory
*bim
;
1687 bfd_vma high_offset
;
1689 bfd_vma loadbase
; /* Bytes. */
1691 unsigned int opb
= bfd_octets_per_byte (templ
, NULL
);
1693 /* Read in the ELF header in external format. */
1694 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1697 bfd_set_error (bfd_error_system_call
);
1702 /* Now check to see if we have a valid ELF file, and one that BFD can
1703 make use of. The magic number must match, the address size ('class')
1704 and byte-swapping must match our XVEC entry. */
1706 if (! elf_file_p (&x_ehdr
)
1707 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1708 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1710 bfd_set_error (bfd_error_wrong_format
);
1714 /* Check that file's byte order matches xvec's */
1715 switch (x_ehdr
.e_ident
[EI_DATA
])
1717 case ELFDATA2MSB
: /* Big-endian */
1718 if (! bfd_header_big_endian (templ
))
1720 bfd_set_error (bfd_error_wrong_format
);
1724 case ELFDATA2LSB
: /* Little-endian */
1725 if (! bfd_header_little_endian (templ
))
1727 bfd_set_error (bfd_error_wrong_format
);
1731 case ELFDATANONE
: /* No data encoding specified */
1732 default: /* Unknown data encoding specified */
1733 bfd_set_error (bfd_error_wrong_format
);
1737 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1739 /* The file header tells where to find the program headers.
1740 These are what we use to actually choose what to read. */
1742 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1744 bfd_set_error (bfd_error_wrong_format
);
1748 if (_bfd_mul_overflow (i_ehdr
.e_phnum
,
1749 sizeof (*x_phdrs
) + sizeof (*i_phdrs
), &amt
))
1751 bfd_set_error (bfd_error_file_too_big
);
1754 x_phdrs
= (Elf_External_Phdr
*) bfd_malloc (amt
);
1755 if (x_phdrs
== NULL
)
1757 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1758 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1762 bfd_set_error (bfd_error_system_call
);
1766 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1772 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1774 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1775 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1777 bfd_vma segment_end
= i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
;
1779 if (segment_end
> high_offset
)
1781 high_offset
= segment_end
;
1782 last_phdr
= &i_phdrs
[i
];
1785 /* If this program header covers offset zero, where the file
1786 header sits, then we can figure out the loadbase. */
1787 if (first_phdr
== NULL
)
1789 bfd_vma p_offset
= i_phdrs
[i
].p_offset
; /* Octets. */
1790 bfd_vma p_vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1792 if (i_phdrs
[i
].p_align
> 1)
1794 p_offset
&= -(i_phdrs
[i
].p_align
* opb
);
1795 p_vaddr
&= -(i_phdrs
[i
].p_align
* opb
);
1799 loadbase
= ehdr_vma
- p_vaddr
/ opb
;
1800 first_phdr
= &i_phdrs
[i
];
1805 if (high_offset
== 0)
1807 /* There were no PT_LOAD segments, so we don't have anything to read. */
1809 bfd_set_error (bfd_error_wrong_format
);
1814 if (i_ehdr
.e_shoff
!= 0 && i_ehdr
.e_shnum
!= 0 && i_ehdr
.e_shentsize
!= 0)
1816 shdr_end
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1818 if (last_phdr
->p_filesz
!= last_phdr
->p_memsz
)
1820 /* If the last PT_LOAD header has a bss area then ld.so will
1821 have cleared anything past p_filesz, zapping the section
1824 else if (size
>= shdr_end
)
1828 bfd_vma page_size
= get_elf_backend_data (templ
)->minpagesize
;
1829 bfd_vma segment_end
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1831 /* Assume we loaded full pages, allowing us to sometimes see
1833 if (page_size
> 1 && shdr_end
> segment_end
)
1835 bfd_vma page_end
= (segment_end
+ page_size
- 1) & -page_size
;
1837 if (page_end
>= shdr_end
)
1838 /* Whee, section headers covered. */
1839 high_offset
= shdr_end
;
1844 /* Now we know the size of the whole image we want read in. */
1845 contents
= (bfd_byte
*) bfd_zmalloc (high_offset
);
1846 if (contents
== NULL
)
1852 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1853 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1855 bfd_vma start
= i_phdrs
[i
].p_offset
; /* Octets. */
1856 bfd_vma end
= start
+ i_phdrs
[i
].p_filesz
; /* Octets. */
1857 bfd_vma vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1859 /* Extend the beginning of the first pt_load to cover file
1860 header and program headers, if we proved earlier that its
1861 aligned offset is 0. */
1862 if (first_phdr
== &i_phdrs
[i
])
1867 /* Extend the end of the last pt_load to cover section headers. */
1868 if (last_phdr
== &i_phdrs
[i
])
1870 err
= target_read_memory (loadbase
+ vaddr
/ opb
,
1871 contents
+ start
, end
- start
);
1876 bfd_set_error (bfd_error_system_call
);
1883 /* If the segments visible in memory didn't include the section headers,
1884 then clear them from the file header. */
1885 if (high_offset
< shdr_end
)
1887 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1888 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1889 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1892 /* This will normally have been in the first PT_LOAD segment. But it
1893 conceivably could be missing, and we might have just changed it. */
1894 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1896 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1897 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1903 nbfd
= _bfd_new_bfd ();
1905 || !bfd_set_filename (nbfd
, "<in-memory>"))
1911 nbfd
->xvec
= templ
->xvec
;
1912 bim
->size
= high_offset
;
1913 bim
->buffer
= contents
;
1914 nbfd
->iostream
= bim
;
1915 nbfd
->flags
= BFD_IN_MEMORY
;
1916 nbfd
->iovec
= &_bfd_memory_iovec
;
1918 nbfd
->direction
= read_direction
;
1919 nbfd
->mtime
= time (NULL
);
1920 nbfd
->mtime_set
= TRUE
;
1923 *loadbasep
= loadbase
;
1927 /* Function for ELF_R_INFO. */
1930 NAME(elf
,r_info
) (bfd_vma sym
, bfd_vma type
)
1932 return ELF_R_INFO (sym
, type
);
1935 /* Function for ELF_R_SYM. */
1938 NAME(elf
,r_sym
) (bfd_vma r_info
)
1940 return ELF_R_SYM (r_info
);
1943 #include "elfcore.h"
1945 /* Size-dependent data and functions. */
1946 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1947 sizeof (Elf_External_Ehdr
),
1948 sizeof (Elf_External_Phdr
),
1949 sizeof (Elf_External_Shdr
),
1950 sizeof (Elf_External_Rel
),
1951 sizeof (Elf_External_Rela
),
1952 sizeof (Elf_External_Sym
),
1953 sizeof (Elf_External_Dyn
),
1954 sizeof (Elf_External_Note
),
1957 ARCH_SIZE
, LOG_FILE_ALIGN
,
1958 ELFCLASS
, EV_CURRENT
,
1959 elf_write_out_phdrs
,
1960 elf_write_shdrs_and_ehdr
,
1961 elf_checksum_contents
,
1964 elf_swap_symbol_out
,
1965 elf_slurp_reloc_table
,
1966 elf_slurp_symbol_table
,