1 /* ELF executable support for BFD.
2 Copyright (C) 1991-2018 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 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
318 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
319 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
320 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
321 dst
->bfd_section
= NULL
;
322 dst
->contents
= NULL
;
325 /* Translate an ELF section header table entry in internal format into an
326 ELF section header table entry in external format. */
329 elf_swap_shdr_out (bfd
*abfd
,
330 const Elf_Internal_Shdr
*src
,
331 Elf_External_Shdr
*dst
)
333 /* note that all elements of dst are *arrays of unsigned char* already... */
334 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
335 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
336 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
337 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
338 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
339 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
340 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
341 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
342 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
343 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
346 /* Translate an ELF program header table entry in external format into an
347 ELF program header table entry in internal format. */
350 elf_swap_phdr_in (bfd
*abfd
,
351 const Elf_External_Phdr
*src
,
352 Elf_Internal_Phdr
*dst
)
354 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
356 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
357 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
358 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
361 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
362 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
366 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
367 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
369 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
370 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
371 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
375 elf_swap_phdr_out (bfd
*abfd
,
376 const Elf_Internal_Phdr
*src
,
377 Elf_External_Phdr
*dst
)
379 const struct elf_backend_data
*bed
;
382 bed
= get_elf_backend_data (abfd
);
383 p_paddr
= bed
->want_p_paddr_set_to_zero
? 0 : src
->p_paddr
;
385 /* note that all elements of dst are *arrays of unsigned char* already... */
386 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
387 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
388 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
389 H_PUT_WORD (abfd
, p_paddr
, dst
->p_paddr
);
390 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
391 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
392 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
393 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
396 /* Translate an ELF reloc from external format to internal format. */
398 elf_swap_reloc_in (bfd
*abfd
,
400 Elf_Internal_Rela
*dst
)
402 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
403 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
404 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
409 elf_swap_reloca_in (bfd
*abfd
,
411 Elf_Internal_Rela
*dst
)
413 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
414 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
415 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
416 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
419 /* Translate an ELF reloc from internal format to external format. */
421 elf_swap_reloc_out (bfd
*abfd
,
422 const Elf_Internal_Rela
*src
,
425 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
426 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
427 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
431 elf_swap_reloca_out (bfd
*abfd
,
432 const Elf_Internal_Rela
*src
,
435 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
436 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
437 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
438 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
442 elf_swap_dyn_in (bfd
*abfd
,
444 Elf_Internal_Dyn
*dst
)
446 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
448 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
449 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
453 elf_swap_dyn_out (bfd
*abfd
,
454 const Elf_Internal_Dyn
*src
,
457 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
459 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
460 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
463 /* ELF .o/exec file reading */
465 /* Begin processing a given object.
467 First we validate the file by reading in the ELF header and checking
470 static inline bfd_boolean
471 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
473 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
474 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
475 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
476 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
479 /* Check to see if the file associated with ABFD matches the target vector
482 Note that we may be called several times with the same ABFD, but different
483 target vectors, most of which will not match. We have to avoid leaving
484 any side effects in ABFD, or any data it points to (like tdata), if the
485 file does not match the target vector. */
488 elf_object_p (bfd
*abfd
)
490 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
491 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
492 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
493 Elf_Internal_Shdr i_shdr
;
494 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
495 unsigned int shindex
;
496 const struct elf_backend_data
*ebd
;
499 const bfd_target
*target
;
501 /* Read in the ELF header in external format. */
503 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
505 if (bfd_get_error () != bfd_error_system_call
)
506 goto got_wrong_format_error
;
511 /* Now check to see if we have a valid ELF file, and one that BFD can
512 make use of. The magic number must match, the address size ('class')
513 and byte-swapping must match our XVEC entry, and it must have a
514 section header table (FIXME: See comments re sections at top of this
517 if (! elf_file_p (&x_ehdr
)
518 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
519 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
520 goto got_wrong_format_error
;
522 /* Check that file's byte order matches xvec's */
523 switch (x_ehdr
.e_ident
[EI_DATA
])
525 case ELFDATA2MSB
: /* Big-endian */
526 if (! bfd_header_big_endian (abfd
))
527 goto got_wrong_format_error
;
529 case ELFDATA2LSB
: /* Little-endian */
530 if (! bfd_header_little_endian (abfd
))
531 goto got_wrong_format_error
;
533 case ELFDATANONE
: /* No data encoding specified */
534 default: /* Unknown data encoding specified */
535 goto got_wrong_format_error
;
540 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
541 the tdata pointer in the bfd. */
543 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
546 /* Now that we know the byte order, swap in the rest of the header */
547 i_ehdrp
= elf_elfheader (abfd
);
548 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
550 elf_debug_file (i_ehdrp
);
553 /* Reject ET_CORE (header indicates core file, not object file) */
554 if (i_ehdrp
->e_type
== ET_CORE
)
555 goto got_wrong_format_error
;
557 /* If this is a relocatable file and there is no section header
558 table, then we're hosed. */
559 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
560 goto got_wrong_format_error
;
562 /* As a simple sanity check, verify that what BFD thinks is the
563 size of each section header table entry actually matches the size
564 recorded in the file, but only if there are any sections. */
565 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
566 goto got_wrong_format_error
;
568 /* Further sanity check. */
569 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
570 goto got_wrong_format_error
;
572 ebd
= get_elf_backend_data (abfd
);
573 if (ebd
->s
->arch_size
!= ARCH_SIZE
)
574 goto got_wrong_format_error
;
576 /* Check that the ELF e_machine field matches what this particular
577 BFD format expects. */
578 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
579 && (ebd
->elf_machine_alt1
== 0
580 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
581 && (ebd
->elf_machine_alt2
== 0
582 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
)
583 && ebd
->elf_machine_code
!= EM_NONE
)
584 goto got_wrong_format_error
;
586 if (i_ehdrp
->e_type
== ET_EXEC
)
587 abfd
->flags
|= EXEC_P
;
588 else if (i_ehdrp
->e_type
== ET_DYN
)
589 abfd
->flags
|= DYNAMIC
;
591 if (i_ehdrp
->e_phnum
> 0)
592 abfd
->flags
|= D_PAGED
;
594 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
596 /* It's OK if this fails for the generic target. */
597 if (ebd
->elf_machine_code
!= EM_NONE
)
601 if (ebd
->elf_machine_code
!= EM_NONE
602 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
603 && ebd
->elf_osabi
!= ELFOSABI_NONE
)
604 goto got_wrong_format_error
;
606 if (i_ehdrp
->e_shoff
!= 0)
608 file_ptr where
= (file_ptr
) i_ehdrp
->e_shoff
;
610 /* Seek to the section header table in the file. */
611 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
614 /* Read the first section header at index 0, and convert to internal
616 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
618 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
620 /* If the section count is zero, the actual count is in the first
622 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
624 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
625 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
626 || i_ehdrp
->e_shnum
!= i_shdr
.sh_size
627 || i_ehdrp
->e_shnum
== 0)
628 goto got_wrong_format_error
;
631 /* And similarly for the string table index. */
632 if (i_ehdrp
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
634 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
635 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
636 goto got_wrong_format_error
;
639 /* And program headers. */
640 if (i_ehdrp
->e_phnum
== PN_XNUM
&& i_shdr
.sh_info
!= 0)
642 i_ehdrp
->e_phnum
= i_shdr
.sh_info
;
643 if (i_ehdrp
->e_phnum
!= i_shdr
.sh_info
)
644 goto got_wrong_format_error
;
647 /* Sanity check that we can read all of the section headers.
648 It ought to be good enough to just read the last one. */
649 if (i_ehdrp
->e_shnum
!= 1)
651 /* Check that we don't have a totally silly number of sections. */
652 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
653 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
654 goto got_wrong_format_error
;
656 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
657 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
658 goto got_wrong_format_error
;
660 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
662 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
665 /* Back to where we were. */
666 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
667 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
672 /* Allocate space for a copy of the section header table in
674 if (i_ehdrp
->e_shnum
!= 0)
676 Elf_Internal_Shdr
*shdrp
;
677 unsigned int num_sec
;
680 if (i_ehdrp
->e_shnum
> ((bfd_size_type
) -1) / sizeof (*i_shdrp
))
681 goto got_wrong_format_error
;
683 amt
= sizeof (*i_shdrp
) * (bfd_size_type
) i_ehdrp
->e_shnum
;
684 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
687 num_sec
= i_ehdrp
->e_shnum
;
688 elf_numsections (abfd
) = num_sec
;
689 amt
= sizeof (i_shdrp
) * num_sec
;
690 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
691 if (!elf_elfsections (abfd
))
694 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
695 for (shdrp
= i_shdrp
, shindex
= 0; shindex
< num_sec
; shindex
++)
696 elf_elfsections (abfd
)[shindex
] = shdrp
++;
698 /* Read in the rest of the section header table and convert it
700 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
702 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
704 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
706 /* Sanity check sh_link and sh_info. */
707 if (i_shdrp
[shindex
].sh_link
>= num_sec
)
709 /* PR 10478: Accept Solaris binaries with a sh_link
710 field set to SHN_BEFORE or SHN_AFTER. */
711 switch (ebd
->elf_machine_code
)
720 if (i_shdrp
[shindex
].sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
721 || i_shdrp
[shindex
].sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
723 /* Otherwise fall through. */
725 goto got_wrong_format_error
;
729 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
730 || i_shdrp
[shindex
].sh_type
== SHT_RELA
731 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
732 && i_shdrp
[shindex
].sh_info
>= num_sec
)
733 goto got_wrong_format_error
;
735 /* If the section is loaded, but not page aligned, clear
737 if (i_shdrp
[shindex
].sh_size
!= 0
738 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
739 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
740 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
743 abfd
->flags
&= ~D_PAGED
;
747 /* A further sanity check. */
748 if (i_ehdrp
->e_shnum
!= 0)
750 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
))
753 We used to just goto got_wrong_format_error here
754 but there are binaries in existance for which this test
755 will prevent the binutils from working with them at all.
756 So we are kind, and reset the string index value to 0
757 so that at least some processing can be done. */
758 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
760 (_("warning: %pB has a corrupt string table index - ignoring"),
764 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
765 goto got_wrong_format_error
;
767 /* Read in the program headers. */
768 if (i_ehdrp
->e_phnum
== 0)
769 elf_tdata (abfd
)->phdr
= NULL
;
772 Elf_Internal_Phdr
*i_phdr
;
776 if (i_ehdrp
->e_phnum
> ((bfd_size_type
) -1) / sizeof (*i_phdr
))
777 goto got_wrong_format_error
;
779 amt
= (bfd_size_type
) i_ehdrp
->e_phnum
* sizeof (*i_phdr
);
780 elf_tdata (abfd
)->phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
781 if (elf_tdata (abfd
)->phdr
== NULL
)
783 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
785 i_phdr
= elf_tdata (abfd
)->phdr
;
786 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
788 Elf_External_Phdr x_phdr
;
790 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
792 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
796 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
798 unsigned int num_sec
;
800 /* Once all of the section headers have been read and converted, we
801 can start processing them. Note that the first section header is
802 a dummy placeholder entry, so we ignore it. */
803 num_sec
= elf_numsections (abfd
);
804 for (shindex
= 1; shindex
< num_sec
; shindex
++)
805 if (!bfd_section_from_shdr (abfd
, shindex
))
808 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
809 if (! _bfd_elf_setup_sections (abfd
))
810 goto got_wrong_format_error
;
813 /* Let the backend double check the format and override global
815 if (ebd
->elf_backend_object_p
)
817 if (! (*ebd
->elf_backend_object_p
) (abfd
))
818 goto got_wrong_format_error
;
821 /* Remember the entry point specified in the ELF file header. */
822 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
824 /* If we have created any reloc sections that are associated with
825 debugging sections, mark the reloc sections as debugging as well. */
826 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
828 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
829 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
830 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
832 unsigned long targ_index
;
835 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
836 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
838 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
839 s
->flags
|= SEC_DEBUGGING
;
844 got_wrong_format_error
:
845 bfd_set_error (bfd_error_wrong_format
);
851 /* ELF .o/exec file writing */
853 /* Write out the relocs. */
856 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
858 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
859 Elf_Internal_Shdr
*rela_hdr
;
861 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
868 /* If we have already failed, don't do anything. */
872 if ((sec
->flags
& SEC_RELOC
) == 0)
875 /* The linker backend writes the relocs out itself, and sets the
876 reloc_count field to zero to inhibit writing them here. Also,
877 sometimes the SEC_RELOC flag gets set even when there aren't any
879 if (sec
->reloc_count
== 0)
882 /* If we have opened an existing file for update, reloc_count may be
883 set even though we are not linking. In that case we have nothing
885 if (sec
->orelocation
== NULL
)
888 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
889 if (rela_hdr
== NULL
)
890 rela_hdr
= elf_section_data (sec
)->rel
.hdr
;
892 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
893 rela_hdr
->contents
= (unsigned char *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
894 if (rela_hdr
->contents
== NULL
)
900 /* Figure out whether the relocations are RELA or REL relocations. */
901 if (rela_hdr
->sh_type
== SHT_RELA
)
903 swap_out
= elf_swap_reloca_out
;
904 extsize
= sizeof (Elf_External_Rela
);
906 else if (rela_hdr
->sh_type
== SHT_REL
)
908 swap_out
= elf_swap_reloc_out
;
909 extsize
= sizeof (Elf_External_Rel
);
912 /* Every relocation section should be either an SHT_RELA or an
916 /* The address of an ELF reloc is section relative for an object
917 file, and absolute for an executable file or shared library.
918 The address of a BFD reloc is always section relative. */
920 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
921 addr_offset
= sec
->vma
;
923 /* orelocation has the data, reloc_count has the count... */
926 dst_rela
= rela_hdr
->contents
;
928 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
930 Elf_Internal_Rela src_rela
;
935 ptr
= sec
->orelocation
[idx
];
936 sym
= *ptr
->sym_ptr_ptr
;
939 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
944 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
953 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
954 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
955 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
961 if (ptr
->howto
== NULL
)
967 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
968 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
969 src_rela
.r_addend
= ptr
->addend
;
970 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
974 /* Write out the program headers. */
977 elf_write_out_phdrs (bfd
*abfd
,
978 const Elf_Internal_Phdr
*phdr
,
983 Elf_External_Phdr extphdr
;
985 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
986 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
987 != sizeof (Elf_External_Phdr
))
994 /* Write out the section headers and the ELF file header. */
997 elf_write_shdrs_and_ehdr (bfd
*abfd
)
999 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1000 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1001 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1002 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1006 i_ehdrp
= elf_elfheader (abfd
);
1007 i_shdrp
= elf_elfsections (abfd
);
1009 /* swap the header before spitting it out... */
1012 elf_debug_file (i_ehdrp
);
1014 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1015 amt
= sizeof (x_ehdr
);
1016 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1017 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1020 /* Some fields in the first section header handle overflow of ehdr
1022 if (i_ehdrp
->e_phnum
>= PN_XNUM
)
1023 i_shdrp
[0]->sh_info
= i_ehdrp
->e_phnum
;
1024 if (i_ehdrp
->e_shnum
>= (SHN_LORESERVE
& 0xffff))
1025 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1026 if (i_ehdrp
->e_shstrndx
>= (SHN_LORESERVE
& 0xffff))
1027 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1029 /* at this point we've concocted all the ELF sections... */
1030 amt
= i_ehdrp
->e_shnum
;
1031 amt
*= sizeof (*x_shdrp
);
1032 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1036 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1039 elf_debug_section (count
, *i_shdrp
);
1041 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1043 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1044 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1047 /* need to dump the string table too... */
1053 elf_checksum_contents (bfd
*abfd
,
1054 void (*process
) (const void *, size_t, void *),
1057 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1058 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
1059 Elf_Internal_Phdr
*i_phdrp
= elf_tdata (abfd
)->phdr
;
1060 unsigned int count
, num
;
1063 Elf_External_Ehdr x_ehdr
;
1064 Elf_Internal_Ehdr i_ehdr
;
1067 i_ehdr
.e_phoff
= i_ehdr
.e_shoff
= 0;
1068 elf_swap_ehdr_out (abfd
, &i_ehdr
, &x_ehdr
);
1069 (*process
) (&x_ehdr
, sizeof x_ehdr
, arg
);
1072 num
= i_ehdrp
->e_phnum
;
1073 for (count
= 0; count
< num
; count
++)
1075 Elf_External_Phdr x_phdr
;
1076 elf_swap_phdr_out (abfd
, &i_phdrp
[count
], &x_phdr
);
1077 (*process
) (&x_phdr
, sizeof x_phdr
, arg
);
1080 num
= elf_numsections (abfd
);
1081 for (count
= 0; count
< num
; count
++)
1083 Elf_Internal_Shdr i_shdr
;
1084 Elf_External_Shdr x_shdr
;
1085 bfd_byte
*contents
, *free_contents
;
1087 i_shdr
= *i_shdrp
[count
];
1088 i_shdr
.sh_offset
= 0;
1090 elf_swap_shdr_out (abfd
, &i_shdr
, &x_shdr
);
1091 (*process
) (&x_shdr
, sizeof x_shdr
, arg
);
1093 /* Process the section's contents, if it has some.
1094 PR ld/12451: Read them in if necessary. */
1095 if (i_shdr
.sh_type
== SHT_NOBITS
)
1097 free_contents
= NULL
;
1098 contents
= i_shdr
.contents
;
1099 if (contents
== NULL
)
1103 sec
= bfd_section_from_elf_index (abfd
, count
);
1106 contents
= sec
->contents
;
1107 if (contents
== NULL
)
1109 /* Force rereading from file. */
1110 sec
->flags
&= ~SEC_IN_MEMORY
;
1111 if (!bfd_malloc_and_get_section (abfd
, sec
, &free_contents
))
1113 contents
= free_contents
;
1117 if (contents
!= NULL
)
1119 (*process
) (contents
, i_shdr
.sh_size
, arg
);
1120 if (free_contents
!= NULL
)
1121 free (free_contents
);
1129 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
1131 Elf_Internal_Shdr
*hdr
;
1132 Elf_Internal_Shdr
*verhdr
;
1133 unsigned long symcount
; /* Number of external ELF symbols */
1134 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1135 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1136 Elf_Internal_Sym
*isym
;
1137 Elf_Internal_Sym
*isymend
;
1138 Elf_Internal_Sym
*isymbuf
= NULL
;
1139 Elf_External_Versym
*xver
;
1140 Elf_External_Versym
*xverbuf
= NULL
;
1141 const struct elf_backend_data
*ebd
;
1144 /* Read each raw ELF symbol, converting from external ELF form to
1145 internal ELF form, and then using the information to create a
1146 canonical bfd symbol table entry.
1148 Note that we allocate the initial bfd canonical symbol buffer
1149 based on a one-to-one mapping of the ELF symbols to canonical
1150 symbols. We actually use all the ELF symbols, so there will be no
1151 space left over at the end. When we have all the symbols, we
1152 build the caller's pointer vector. */
1156 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1161 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1162 if (elf_dynversym (abfd
) == 0)
1165 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1166 if ((elf_dynverdef (abfd
) != 0
1167 && elf_tdata (abfd
)->verdef
== NULL
)
1168 || (elf_dynverref (abfd
) != 0
1169 && elf_tdata (abfd
)->verref
== NULL
))
1171 if (!_bfd_elf_slurp_version_tables (abfd
, FALSE
))
1176 ebd
= get_elf_backend_data (abfd
);
1177 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1179 sym
= symbase
= NULL
;
1182 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1184 if (isymbuf
== NULL
)
1188 amt
*= sizeof (elf_symbol_type
);
1189 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1190 if (symbase
== (elf_symbol_type
*) NULL
)
1193 /* Read the raw ELF version symbol information. */
1195 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1198 /* xgettext:c-format */
1199 (_("%pB: version count (%" PRId64
")"
1200 " does not match symbol count (%ld)"),
1202 (int64_t) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1205 /* Slurp in the symbols without the version information,
1206 since that is more helpful than just quitting. */
1212 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1215 xverbuf
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1216 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1219 if (bfd_bread (xverbuf
, verhdr
->sh_size
, abfd
) != verhdr
->sh_size
)
1223 /* Skip first symbol, which is a null dummy. */
1227 isymend
= isymbuf
+ symcount
;
1228 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1230 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1232 sym
->symbol
.the_bfd
= abfd
;
1233 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1234 sym
->symbol
.value
= isym
->st_value
;
1236 if (isym
->st_shndx
== SHN_UNDEF
)
1238 sym
->symbol
.section
= bfd_und_section_ptr
;
1240 else if (isym
->st_shndx
== SHN_ABS
)
1242 sym
->symbol
.section
= bfd_abs_section_ptr
;
1244 else if (isym
->st_shndx
== SHN_COMMON
)
1246 sym
->symbol
.section
= bfd_com_section_ptr
;
1247 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
1249 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
1253 flagword flags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
1255 xc
= bfd_make_section_with_flags (abfd
, "COMMON", flags
);
1259 sym
->symbol
.section
= xc
;
1261 /* Elf puts the alignment into the `value' field, and
1262 the size into the `size' field. BFD wants to see the
1263 size in the value field, and doesn't care (at the
1264 moment) about the alignment. */
1265 sym
->symbol
.value
= isym
->st_size
;
1270 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1271 if (sym
->symbol
.section
== NULL
)
1273 /* This symbol is in a section for which we did not
1274 create a BFD section. Just use bfd_abs_section,
1275 although it is wrong. FIXME. */
1276 sym
->symbol
.section
= bfd_abs_section_ptr
;
1280 /* If this is a relocatable file, then the symbol value is
1281 already section relative. */
1282 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1283 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1285 switch (ELF_ST_BIND (isym
->st_info
))
1288 sym
->symbol
.flags
|= BSF_LOCAL
;
1291 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1292 sym
->symbol
.flags
|= BSF_GLOBAL
;
1295 sym
->symbol
.flags
|= BSF_WEAK
;
1297 case STB_GNU_UNIQUE
:
1298 sym
->symbol
.flags
|= BSF_GNU_UNIQUE
;
1302 switch (ELF_ST_TYPE (isym
->st_info
))
1305 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1308 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1311 sym
->symbol
.flags
|= BSF_FUNCTION
;
1314 /* FIXME: Do we have to put the size field into the value field
1315 as we do with symbols in SHN_COMMON sections (see above) ? */
1316 sym
->symbol
.flags
|= BSF_ELF_COMMON
;
1319 sym
->symbol
.flags
|= BSF_OBJECT
;
1322 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1325 sym
->symbol
.flags
|= BSF_RELC
;
1328 sym
->symbol
.flags
|= BSF_SRELC
;
1331 sym
->symbol
.flags
|= BSF_GNU_INDIRECT_FUNCTION
;
1336 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1340 Elf_Internal_Versym iversym
;
1342 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1343 sym
->version
= iversym
.vs_vers
;
1347 /* Do some backend-specific processing on this symbol. */
1348 if (ebd
->elf_backend_symbol_processing
)
1349 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1353 /* Do some backend-specific processing on this symbol table. */
1354 if (ebd
->elf_backend_symbol_table_processing
)
1355 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1357 /* We rely on the zalloc to clear out the final symbol entry. */
1359 symcount
= sym
- symbase
;
1361 /* Fill in the user's symbol pointer vector if needed. */
1369 *symptrs
++ = &sym
->symbol
;
1372 *symptrs
= 0; /* Final null pointer */
1375 if (xverbuf
!= NULL
)
1377 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1382 if (xverbuf
!= NULL
)
1384 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1389 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1393 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1395 Elf_Internal_Shdr
*rel_hdr
,
1396 bfd_size_type reloc_count
,
1399 bfd_boolean dynamic
)
1401 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1402 void *allocated
= NULL
;
1403 bfd_byte
*native_relocs
;
1407 unsigned int symcount
;
1409 allocated
= bfd_malloc (rel_hdr
->sh_size
);
1410 if (allocated
== NULL
)
1413 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1414 || (bfd_bread (allocated
, rel_hdr
->sh_size
, abfd
)
1415 != rel_hdr
->sh_size
))
1418 native_relocs
= (bfd_byte
*) allocated
;
1420 entsize
= rel_hdr
->sh_entsize
;
1421 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1422 || entsize
== sizeof (Elf_External_Rela
));
1425 symcount
= bfd_get_dynamic_symcount (abfd
);
1427 symcount
= bfd_get_symcount (abfd
);
1429 for (i
= 0, relent
= relents
;
1431 i
++, relent
++, native_relocs
+= entsize
)
1434 Elf_Internal_Rela rela
;
1436 if (entsize
== sizeof (Elf_External_Rela
))
1437 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1439 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1441 /* The address of an ELF reloc is section relative for an object
1442 file, and absolute for an executable file or shared library.
1443 The address of a normal BFD reloc is always section relative,
1444 and the address of a dynamic reloc is absolute.. */
1445 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1446 relent
->address
= rela
.r_offset
;
1448 relent
->address
= rela
.r_offset
- asect
->vma
;
1450 if (ELF_R_SYM (rela
.r_info
) == STN_UNDEF
)
1451 /* FIXME: This and the error case below mean that we have a
1452 symbol on relocs that is not elf_symbol_type. */
1453 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1454 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1457 /* xgettext:c-format */
1458 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
1459 abfd
, asect
, i
, (long) ELF_R_SYM (rela
.r_info
));
1460 bfd_set_error (bfd_error_bad_value
);
1461 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1467 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1469 relent
->sym_ptr_ptr
= ps
;
1472 relent
->addend
= rela
.r_addend
;
1474 if ((entsize
== sizeof (Elf_External_Rela
)
1475 && ebd
->elf_info_to_howto
!= NULL
)
1476 || ebd
->elf_info_to_howto_rel
== NULL
)
1477 res
= ebd
->elf_info_to_howto (abfd
, relent
, &rela
);
1479 res
= ebd
->elf_info_to_howto_rel (abfd
, relent
, &rela
);
1481 if (! res
|| relent
->howto
== NULL
)
1485 if (allocated
!= NULL
)
1490 if (allocated
!= NULL
)
1495 /* Read in and swap the external relocs. */
1498 elf_slurp_reloc_table (bfd
*abfd
,
1501 bfd_boolean dynamic
)
1503 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1504 Elf_Internal_Shdr
*rel_hdr
;
1505 Elf_Internal_Shdr
*rel_hdr2
;
1506 bfd_size_type reloc_count
;
1507 bfd_size_type reloc_count2
;
1511 if (asect
->relocation
!= NULL
)
1516 if ((asect
->flags
& SEC_RELOC
) == 0
1517 || asect
->reloc_count
== 0)
1520 rel_hdr
= d
->rel
.hdr
;
1521 reloc_count
= rel_hdr
? NUM_SHDR_ENTRIES (rel_hdr
) : 0;
1522 rel_hdr2
= d
->rela
.hdr
;
1523 reloc_count2
= rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0;
1525 /* PR 17512: file: 0b4f81b7. */
1526 if (asect
->reloc_count
!= reloc_count
+ reloc_count2
)
1528 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
1529 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1534 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1535 case because relocations against this section may use the
1536 dynamic symbol table, and in that case bfd_section_from_shdr
1537 in elf.c does not update the RELOC_COUNT. */
1538 if (asect
->size
== 0)
1541 rel_hdr
= &d
->this_hdr
;
1542 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1547 amt
= (reloc_count
+ reloc_count2
) * sizeof (arelent
);
1548 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1549 if (relents
== NULL
)
1553 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1554 rel_hdr
, reloc_count
,
1560 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1561 rel_hdr2
, reloc_count2
,
1562 relents
+ reloc_count
,
1566 asect
->relocation
= relents
;
1572 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1574 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1575 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1578 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1579 (long) hdr
->sh_name
,
1580 (long) hdr
->sh_type
,
1581 (long) hdr
->sh_flags
);
1583 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1584 (long) hdr
->sh_addr
,
1585 (long) hdr
->sh_offset
,
1586 (long) hdr
->sh_size
);
1588 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1589 (long) hdr
->sh_link
,
1590 (long) hdr
->sh_info
,
1591 (long) hdr
->sh_addralign
);
1592 fprintf (stderr
, "sh_entsize = %ld\n",
1593 (long) hdr
->sh_entsize
);
1600 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1602 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1603 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1604 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1605 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1606 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1607 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1608 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1612 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1613 reconstruct an ELF file by reading the segments out of remote
1614 memory based on the ELF file header at EHDR_VMA and the ELF program
1615 headers it points to. If non-zero, SIZE is the known extent of the
1616 object. If not null, *LOADBASEP is filled in with the difference
1617 between the VMAs from which the segments were read, and the VMAs
1618 the file headers (and hence BFD's idea of each section's VMA) put
1621 The function TARGET_READ_MEMORY is called to copy LEN bytes from
1622 the remote memory at target address VMA into the local buffer at
1623 MYADDR; it should return zero on success or an `errno' code on
1624 failure. TEMPL must be a BFD for a target with the word size and
1625 byte order found in the remote memory. */
1628 NAME(_bfd_elf
,bfd_from_remote_memory
)
1633 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
1635 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1636 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1637 Elf_External_Phdr
*x_phdrs
;
1638 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
, *first_phdr
;
1640 struct bfd_in_memory
*bim
;
1644 bfd_vma high_offset
;
1648 /* Read in the ELF header in external format. */
1649 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1652 bfd_set_error (bfd_error_system_call
);
1657 /* Now check to see if we have a valid ELF file, and one that BFD can
1658 make use of. The magic number must match, the address size ('class')
1659 and byte-swapping must match our XVEC entry. */
1661 if (! elf_file_p (&x_ehdr
)
1662 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1663 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1665 bfd_set_error (bfd_error_wrong_format
);
1669 /* Check that file's byte order matches xvec's */
1670 switch (x_ehdr
.e_ident
[EI_DATA
])
1672 case ELFDATA2MSB
: /* Big-endian */
1673 if (! bfd_header_big_endian (templ
))
1675 bfd_set_error (bfd_error_wrong_format
);
1679 case ELFDATA2LSB
: /* Little-endian */
1680 if (! bfd_header_little_endian (templ
))
1682 bfd_set_error (bfd_error_wrong_format
);
1686 case ELFDATANONE
: /* No data encoding specified */
1687 default: /* Unknown data encoding specified */
1688 bfd_set_error (bfd_error_wrong_format
);
1692 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1694 /* The file header tells where to find the program headers.
1695 These are what we use to actually choose what to read. */
1697 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1699 bfd_set_error (bfd_error_wrong_format
);
1703 x_phdrs
= (Elf_External_Phdr
*)
1704 bfd_malloc (i_ehdr
.e_phnum
* (sizeof *x_phdrs
+ sizeof *i_phdrs
));
1705 if (x_phdrs
== NULL
)
1707 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1708 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1712 bfd_set_error (bfd_error_system_call
);
1716 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1722 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1724 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1725 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1727 bfd_vma segment_end
= i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
;
1729 if (segment_end
> high_offset
)
1731 high_offset
= segment_end
;
1732 last_phdr
= &i_phdrs
[i
];
1735 /* If this program header covers offset zero, where the file
1736 header sits, then we can figure out the loadbase. */
1737 if (first_phdr
== NULL
)
1739 bfd_vma p_offset
= i_phdrs
[i
].p_offset
;
1740 bfd_vma p_vaddr
= i_phdrs
[i
].p_vaddr
;
1742 if (i_phdrs
[i
].p_align
> 1)
1744 p_offset
&= -i_phdrs
[i
].p_align
;
1745 p_vaddr
&= -i_phdrs
[i
].p_align
;
1749 loadbase
= ehdr_vma
- p_vaddr
;
1750 first_phdr
= &i_phdrs
[i
];
1755 if (high_offset
== 0)
1757 /* There were no PT_LOAD segments, so we don't have anything to read. */
1759 bfd_set_error (bfd_error_wrong_format
);
1764 if (i_ehdr
.e_shoff
!= 0 && i_ehdr
.e_shnum
!= 0 && i_ehdr
.e_shentsize
!= 0)
1766 shdr_end
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1768 if (last_phdr
->p_filesz
!= last_phdr
->p_memsz
)
1770 /* If the last PT_LOAD header has a bss area then ld.so will
1771 have cleared anything past p_filesz, zapping the section
1774 else if (size
>= shdr_end
)
1778 bfd_vma page_size
= get_elf_backend_data (templ
)->minpagesize
;
1779 bfd_vma segment_end
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1781 /* Assume we loaded full pages, allowing us to sometimes see
1783 if (page_size
> 1 && shdr_end
> segment_end
)
1785 bfd_vma page_end
= (segment_end
+ page_size
- 1) & -page_size
;
1787 if (page_end
>= shdr_end
)
1788 /* Whee, section headers covered. */
1789 high_offset
= shdr_end
;
1794 /* Now we know the size of the whole image we want read in. */
1795 contents
= (bfd_byte
*) bfd_zmalloc (high_offset
);
1796 if (contents
== NULL
)
1802 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1803 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1805 bfd_vma start
= i_phdrs
[i
].p_offset
;
1806 bfd_vma end
= start
+ i_phdrs
[i
].p_filesz
;
1807 bfd_vma vaddr
= i_phdrs
[i
].p_vaddr
;
1809 /* Extend the beginning of the first pt_load to cover file
1810 header and program headers, if we proved earlier that its
1811 aligned offset is 0. */
1812 if (first_phdr
== &i_phdrs
[i
])
1817 /* Extend the end of the last pt_load to cover section headers. */
1818 if (last_phdr
== &i_phdrs
[i
])
1820 err
= target_read_memory (loadbase
+ vaddr
,
1821 contents
+ start
, end
- start
);
1826 bfd_set_error (bfd_error_system_call
);
1833 /* If the segments visible in memory didn't include the section headers,
1834 then clear them from the file header. */
1835 if (high_offset
< shdr_end
)
1837 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1838 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1839 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1842 /* This will normally have been in the first PT_LOAD segment. But it
1843 conceivably could be missing, and we might have just changed it. */
1844 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1846 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1847 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1853 nbfd
= _bfd_new_bfd ();
1860 nbfd
->filename
= xstrdup ("<in-memory>");
1861 nbfd
->xvec
= templ
->xvec
;
1862 bim
->size
= high_offset
;
1863 bim
->buffer
= contents
;
1864 nbfd
->iostream
= bim
;
1865 nbfd
->flags
= BFD_IN_MEMORY
;
1866 nbfd
->iovec
= &_bfd_memory_iovec
;
1868 nbfd
->direction
= read_direction
;
1869 nbfd
->mtime
= time (NULL
);
1870 nbfd
->mtime_set
= TRUE
;
1873 *loadbasep
= loadbase
;
1877 /* Function for ELF_R_INFO. */
1880 NAME(elf
,r_info
) (bfd_vma sym
, bfd_vma type
)
1882 return ELF_R_INFO (sym
, type
);
1885 /* Function for ELF_R_SYM. */
1888 NAME(elf
,r_sym
) (bfd_vma r_info
)
1890 return ELF_R_SYM (r_info
);
1893 #include "elfcore.h"
1895 /* Size-dependent data and functions. */
1896 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1897 sizeof (Elf_External_Ehdr
),
1898 sizeof (Elf_External_Phdr
),
1899 sizeof (Elf_External_Shdr
),
1900 sizeof (Elf_External_Rel
),
1901 sizeof (Elf_External_Rela
),
1902 sizeof (Elf_External_Sym
),
1903 sizeof (Elf_External_Dyn
),
1904 sizeof (Elf_External_Note
),
1907 ARCH_SIZE
, LOG_FILE_ALIGN
,
1908 ELFCLASS
, EV_CURRENT
,
1909 elf_write_out_phdrs
,
1910 elf_write_shdrs_and_ehdr
,
1911 elf_checksum_contents
,
1914 elf_swap_symbol_out
,
1915 elf_slurp_reloc_table
,
1916 elf_slurp_symbol_table
,