1 /* ELF executable support for BFD.
2 Copyright (C) 1991-2022 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 const char **warn
= _bfd_per_xvec_warn (abfd
->xvec
);
330 *warn
= _("warning: %pB has a section extending past end of file");
334 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
335 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
336 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
337 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
338 dst
->bfd_section
= NULL
;
339 dst
->contents
= NULL
;
342 /* Translate an ELF section header table entry in internal format into an
343 ELF section header table entry in external format. */
346 elf_swap_shdr_out (bfd
*abfd
,
347 const Elf_Internal_Shdr
*src
,
348 Elf_External_Shdr
*dst
)
350 /* note that all elements of dst are *arrays of unsigned char* already... */
351 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
352 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
353 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
354 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
355 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
356 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
357 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
358 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
359 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
360 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
363 /* Translate an ELF program header table entry in external format into an
364 ELF program header table entry in internal format. */
367 elf_swap_phdr_in (bfd
*abfd
,
368 const Elf_External_Phdr
*src
,
369 Elf_Internal_Phdr
*dst
)
371 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
373 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
374 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
375 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
378 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
379 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
383 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
384 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
386 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
387 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
388 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
392 elf_swap_phdr_out (bfd
*abfd
,
393 const Elf_Internal_Phdr
*src
,
394 Elf_External_Phdr
*dst
)
396 const struct elf_backend_data
*bed
;
399 bed
= get_elf_backend_data (abfd
);
400 p_paddr
= bed
->want_p_paddr_set_to_zero
? 0 : src
->p_paddr
;
402 /* note that all elements of dst are *arrays of unsigned char* already... */
403 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
404 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
405 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
406 H_PUT_WORD (abfd
, p_paddr
, dst
->p_paddr
);
407 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
408 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
409 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
410 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
413 /* Translate an ELF reloc from external format to internal format. */
415 elf_swap_reloc_in (bfd
*abfd
,
417 Elf_Internal_Rela
*dst
)
419 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
420 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
421 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
426 elf_swap_reloca_in (bfd
*abfd
,
428 Elf_Internal_Rela
*dst
)
430 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
431 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
432 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
433 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
436 /* Translate an ELF reloc from internal format to external format. */
438 elf_swap_reloc_out (bfd
*abfd
,
439 const Elf_Internal_Rela
*src
,
442 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
443 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
444 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
448 elf_swap_reloca_out (bfd
*abfd
,
449 const Elf_Internal_Rela
*src
,
452 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
453 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
454 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
455 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
459 elf_swap_dyn_in (bfd
*abfd
,
461 Elf_Internal_Dyn
*dst
)
463 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
465 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
466 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
470 elf_swap_dyn_out (bfd
*abfd
,
471 const Elf_Internal_Dyn
*src
,
474 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
476 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
477 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
480 /* ELF .o/exec file reading */
482 /* Begin processing a given object.
484 First we validate the file by reading in the ELF header and checking
488 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
490 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
491 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
492 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
493 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
496 /* Check to see if the file associated with ABFD matches the target vector
499 Note that we may be called several times with the same ABFD, but different
500 target vectors, most of which will not match. We have to avoid leaving
501 any side effects in ABFD, or any data it points to (like tdata), if the
502 file does not match the target vector. */
505 elf_object_p (bfd
*abfd
)
507 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
508 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
509 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
510 Elf_Internal_Shdr i_shdr
;
511 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
512 unsigned int shindex
;
513 const struct elf_backend_data
*ebd
;
515 const bfd_target
*target
;
517 /* Read in the ELF header in external format. */
519 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
521 if (bfd_get_error () != bfd_error_system_call
)
522 goto got_wrong_format_error
;
527 /* Now check to see if we have a valid ELF file, and one that BFD can
528 make use of. The magic number must match, the address size ('class')
529 and byte-swapping must match our XVEC entry, and it must have a
530 section header table (FIXME: See comments re sections at top of this
533 if (! elf_file_p (&x_ehdr
)
534 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
535 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
536 goto got_wrong_format_error
;
538 /* Check that file's byte order matches xvec's */
539 switch (x_ehdr
.e_ident
[EI_DATA
])
541 case ELFDATA2MSB
: /* Big-endian */
542 if (! bfd_header_big_endian (abfd
))
543 goto got_wrong_format_error
;
545 case ELFDATA2LSB
: /* Little-endian */
546 if (! bfd_header_little_endian (abfd
))
547 goto got_wrong_format_error
;
549 case ELFDATANONE
: /* No data encoding specified */
550 default: /* Unknown data encoding specified */
551 goto got_wrong_format_error
;
556 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
557 the tdata pointer in the bfd. */
559 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
562 /* Now that we know the byte order, swap in the rest of the header */
563 i_ehdrp
= elf_elfheader (abfd
);
564 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
566 elf_debug_file (i_ehdrp
);
569 /* Reject ET_CORE (header indicates core file, not object file) */
570 if (i_ehdrp
->e_type
== ET_CORE
)
571 goto got_wrong_format_error
;
573 /* If this is a relocatable file and there is no section header
574 table, then we're hosed. */
575 if (i_ehdrp
->e_shoff
< sizeof (x_ehdr
) && i_ehdrp
->e_type
== ET_REL
)
576 goto got_wrong_format_error
;
578 /* As a simple sanity check, verify that what BFD thinks is the
579 size of each section header table entry actually matches the size
580 recorded in the file, but only if there are any sections. */
581 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
582 goto got_wrong_format_error
;
584 /* Further sanity check. */
585 if (i_ehdrp
->e_shoff
< sizeof (x_ehdr
) && i_ehdrp
->e_shnum
!= 0)
586 goto got_wrong_format_error
;
588 ebd
= get_elf_backend_data (abfd
);
589 if (ebd
->s
->arch_size
!= ARCH_SIZE
)
590 goto got_wrong_format_error
;
592 /* Check that the ELF e_machine field matches what this particular
593 BFD format expects. */
594 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
595 && (ebd
->elf_machine_alt1
== 0
596 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
597 && (ebd
->elf_machine_alt2
== 0
598 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
)
599 && ebd
->elf_machine_code
!= EM_NONE
)
600 goto got_wrong_format_error
;
602 if (i_ehdrp
->e_type
== ET_EXEC
)
603 abfd
->flags
|= EXEC_P
;
604 else if (i_ehdrp
->e_type
== ET_DYN
)
605 abfd
->flags
|= DYNAMIC
;
607 if (i_ehdrp
->e_phnum
> 0)
608 abfd
->flags
|= D_PAGED
;
610 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
612 /* It's OK if this fails for the generic target. */
613 if (ebd
->elf_machine_code
!= EM_NONE
)
617 if (ebd
->elf_machine_code
!= EM_NONE
618 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
619 && ebd
->elf_osabi
!= ELFOSABI_NONE
)
620 goto got_wrong_format_error
;
622 if (i_ehdrp
->e_shoff
>= sizeof (x_ehdr
))
624 file_ptr where
= (file_ptr
) i_ehdrp
->e_shoff
;
626 /* Seek to the section header table in the file. */
627 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
630 /* Read the first section header at index 0, and convert to internal
632 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
634 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
636 /* If the section count is zero, the actual count is in the first
638 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
640 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
641 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
642 || i_ehdrp
->e_shnum
!= i_shdr
.sh_size
643 || i_ehdrp
->e_shnum
== 0)
644 goto got_wrong_format_error
;
647 /* And similarly for the string table index. */
648 if (i_ehdrp
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
650 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
651 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
652 goto got_wrong_format_error
;
655 /* And program headers. */
656 if (i_ehdrp
->e_phnum
== PN_XNUM
&& i_shdr
.sh_info
!= 0)
658 i_ehdrp
->e_phnum
= i_shdr
.sh_info
;
659 if (i_ehdrp
->e_phnum
!= i_shdr
.sh_info
)
660 goto got_wrong_format_error
;
663 /* Sanity check that we can read all of the section headers.
664 It ought to be good enough to just read the last one. */
665 if (i_ehdrp
->e_shnum
!= 1)
667 /* Check that we don't have a totally silly number of sections. */
668 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
669 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
670 goto got_wrong_format_error
;
672 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
673 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
674 goto got_wrong_format_error
;
676 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
678 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
681 /* Back to where we were. */
682 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
683 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
688 /* Allocate space for a copy of the section header table in
690 if (i_ehdrp
->e_shnum
!= 0)
692 Elf_Internal_Shdr
*shdrp
;
693 unsigned int num_sec
;
696 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*i_shdrp
), &amt
))
697 goto got_wrong_format_error
;
698 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
701 num_sec
= i_ehdrp
->e_shnum
;
702 elf_numsections (abfd
) = num_sec
;
703 if (_bfd_mul_overflow (num_sec
, sizeof (i_shdrp
), &amt
))
704 goto got_wrong_format_error
;
705 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
706 if (!elf_elfsections (abfd
))
708 elf_tdata (abfd
)->being_created
= bfd_zalloc (abfd
, num_sec
);
709 if (!elf_tdata (abfd
)->being_created
)
712 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
713 for (shdrp
= i_shdrp
, shindex
= 0; shindex
< num_sec
; shindex
++)
714 elf_elfsections (abfd
)[shindex
] = shdrp
++;
716 /* Read in the rest of the section header table and convert it
718 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
720 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
722 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
724 /* Sanity check sh_link and sh_info. */
725 if (i_shdrp
[shindex
].sh_link
>= num_sec
)
727 /* PR 10478: Accept Solaris binaries with a sh_link
728 field set to SHN_BEFORE or SHN_AFTER. */
729 switch (ebd
->elf_machine_code
)
738 if (i_shdrp
[shindex
].sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
739 || i_shdrp
[shindex
].sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
741 /* Otherwise fall through. */
743 goto got_wrong_format_error
;
747 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
748 || i_shdrp
[shindex
].sh_type
== SHT_RELA
749 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
750 && i_shdrp
[shindex
].sh_info
>= num_sec
)
751 goto got_wrong_format_error
;
753 /* If the section is loaded, but not page aligned, clear
755 if (i_shdrp
[shindex
].sh_size
!= 0
756 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
757 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
758 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
761 abfd
->flags
&= ~D_PAGED
;
764 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
)
765 || i_shdrp
[i_ehdrp
->e_shstrndx
].sh_type
!= SHT_STRTAB
)
768 We used to just goto got_wrong_format_error here
769 but there are binaries in existance for which this test
770 will prevent the binutils from working with them at all.
771 So we are kind, and reset the string index value to 0
772 so that at least some processing can be done. */
773 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
774 if (!abfd
->read_only
)
776 const char **warn
= _bfd_per_xvec_warn (abfd
->xvec
);
777 *warn
= _("warning: %pB has a corrupt string table index");
782 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
783 goto got_wrong_format_error
;
785 /* Read in the program headers. */
786 if (i_ehdrp
->e_phnum
== 0)
787 elf_tdata (abfd
)->phdr
= NULL
;
790 Elf_Internal_Phdr
*i_phdr
;
795 /* Check for a corrupt input file with an impossibly large number
796 of program headers. */
797 filesize
= bfd_get_file_size (abfd
);
799 && i_ehdrp
->e_phnum
> filesize
/ sizeof (Elf_External_Phdr
))
800 goto got_wrong_format_error
;
801 if (_bfd_mul_overflow (i_ehdrp
->e_phnum
, sizeof (*i_phdr
), &amt
))
802 goto got_wrong_format_error
;
803 elf_tdata (abfd
)->phdr
804 = (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
805 if (elf_tdata (abfd
)->phdr
== NULL
)
807 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
809 i_phdr
= elf_tdata (abfd
)->phdr
;
810 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
812 Elf_External_Phdr x_phdr
;
814 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
816 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
817 /* Too much code in BFD relies on alignment being a power of
818 two, as required by the ELF spec. */
819 if (i_phdr
->p_align
!= (i_phdr
->p_align
& -i_phdr
->p_align
))
821 i_phdr
->p_align
&= -i_phdr
->p_align
;
822 if (!abfd
->read_only
)
824 const char **warn
= _bfd_per_xvec_warn (abfd
->xvec
);
825 *warn
= _("warning: %pB has a program header "
826 "with invalid alignment");
833 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
>= sizeof (x_ehdr
))
835 unsigned int num_sec
;
837 /* Once all of the section headers have been read and converted, we
838 can start processing them. Note that the first section header is
839 a dummy placeholder entry, so we ignore it. */
840 num_sec
= elf_numsections (abfd
);
841 for (shindex
= 1; shindex
< num_sec
; shindex
++)
842 if (!bfd_section_from_shdr (abfd
, shindex
))
845 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
846 if (! _bfd_elf_setup_sections (abfd
))
847 goto got_wrong_format_error
;
850 /* Let the backend double check the format and override global
852 if (ebd
->elf_backend_object_p
)
854 if (! (*ebd
->elf_backend_object_p
) (abfd
))
855 goto got_wrong_format_error
;
858 /* Remember the entry point specified in the ELF file header. */
859 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
861 /* If we have created any reloc sections that are associated with
862 debugging sections, mark the reloc sections as debugging as well. */
863 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
865 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
866 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
867 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
869 unsigned long targ_index
;
872 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
873 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
875 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
876 s
->flags
|= SEC_DEBUGGING
;
879 return _bfd_no_cleanup
;
881 got_wrong_format_error
:
882 bfd_set_error (bfd_error_wrong_format
);
888 /* ELF .o/exec file writing */
890 /* Write out the relocs. */
893 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
895 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
896 bool *failedp
= (bool *) data
;
897 Elf_Internal_Shdr
*rela_hdr
;
899 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
907 /* If we have already failed, don't do anything. */
911 if ((sec
->flags
& SEC_RELOC
) == 0)
914 /* The linker backend writes the relocs out itself, and sets the
915 reloc_count field to zero to inhibit writing them here. Also,
916 sometimes the SEC_RELOC flag gets set even when there aren't any
918 if (sec
->reloc_count
== 0)
921 /* If we have opened an existing file for update, reloc_count may be
922 set even though we are not linking. In that case we have nothing
924 if (sec
->orelocation
== NULL
)
927 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
928 if (rela_hdr
== NULL
)
929 rela_hdr
= elf_section_data (sec
)->rel
.hdr
;
931 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
932 if (_bfd_mul_overflow (sec
->reloc_count
, rela_hdr
->sh_entsize
, &amt
)
933 || (rela_hdr
->contents
= bfd_alloc (abfd
, amt
)) == NULL
)
935 bfd_set_error (bfd_error_no_memory
);
940 /* Figure out whether the relocations are RELA or REL relocations. */
941 if (rela_hdr
->sh_type
== SHT_RELA
)
943 swap_out
= elf_swap_reloca_out
;
944 extsize
= sizeof (Elf_External_Rela
);
946 else if (rela_hdr
->sh_type
== SHT_REL
)
948 swap_out
= elf_swap_reloc_out
;
949 extsize
= sizeof (Elf_External_Rel
);
952 /* Every relocation section should be either an SHT_RELA or an
956 /* The address of an ELF reloc is section relative for an object
957 file, and absolute for an executable file or shared library.
958 The address of a BFD reloc is always section relative. */
960 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
961 addr_offset
= sec
->vma
;
963 /* orelocation has the data, reloc_count has the count... */
966 dst_rela
= rela_hdr
->contents
;
968 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
970 Elf_Internal_Rela src_rela
;
975 ptr
= sec
->orelocation
[idx
];
976 sym
= *ptr
->sym_ptr_ptr
;
979 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
984 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
993 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
994 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
995 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
1001 if (ptr
->howto
== NULL
)
1007 #if defined(BFD64) && ARCH_SIZE == 32
1008 if (rela_hdr
->sh_type
== SHT_RELA
1009 && ptr
->howto
->bitsize
> 32
1010 && ptr
->addend
- INT32_MIN
> UINT32_MAX
)
1012 _bfd_error_handler (_("%pB: %pA+%" PRIx64
": "
1013 "relocation addend %" PRIx64
" too large"),
1014 abfd
, sec
, (uint64_t) ptr
->address
,
1015 (uint64_t) ptr
->addend
);
1017 bfd_set_error (bfd_error_bad_value
);
1021 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
1022 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1023 src_rela
.r_addend
= ptr
->addend
;
1024 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
1027 if (elf_section_data (sec
)->has_secondary_relocs
1028 && !bed
->write_secondary_relocs (abfd
, sec
))
1035 /* Write out the program headers. */
1038 elf_write_out_phdrs (bfd
*abfd
,
1039 const Elf_Internal_Phdr
*phdr
,
1044 Elf_External_Phdr extphdr
;
1046 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1047 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
1048 != sizeof (Elf_External_Phdr
))
1055 /* Write out the section headers and the ELF file header. */
1058 elf_write_shdrs_and_ehdr (bfd
*abfd
)
1060 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1061 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1062 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1063 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1067 i_ehdrp
= elf_elfheader (abfd
);
1068 i_shdrp
= elf_elfsections (abfd
);
1070 /* swap the header before spitting it out... */
1073 elf_debug_file (i_ehdrp
);
1075 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1076 amt
= sizeof (x_ehdr
);
1077 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1078 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1081 /* Some fields in the first section header handle overflow of ehdr
1083 if (i_ehdrp
->e_phnum
>= PN_XNUM
)
1084 i_shdrp
[0]->sh_info
= i_ehdrp
->e_phnum
;
1085 if (i_ehdrp
->e_shnum
>= (SHN_LORESERVE
& 0xffff))
1086 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1087 if (i_ehdrp
->e_shstrndx
>= (SHN_LORESERVE
& 0xffff))
1088 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1090 /* at this point we've concocted all the ELF sections... */
1091 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*x_shdrp
), &amt
))
1093 bfd_set_error (bfd_error_no_memory
);
1096 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1100 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1103 elf_debug_section (count
, *i_shdrp
);
1105 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1107 amt
= (bfd_size_type
) i_ehdrp
->e_shnum
* sizeof (*x_shdrp
);
1108 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1109 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1112 /* need to dump the string table too... */
1118 elf_checksum_contents (bfd
*abfd
,
1119 void (*process
) (const void *, size_t, void *),
1122 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1123 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
1124 Elf_Internal_Phdr
*i_phdrp
= elf_tdata (abfd
)->phdr
;
1125 unsigned int count
, num
;
1128 Elf_External_Ehdr x_ehdr
;
1129 Elf_Internal_Ehdr i_ehdr
;
1132 i_ehdr
.e_phoff
= i_ehdr
.e_shoff
= 0;
1133 elf_swap_ehdr_out (abfd
, &i_ehdr
, &x_ehdr
);
1134 (*process
) (&x_ehdr
, sizeof x_ehdr
, arg
);
1137 num
= i_ehdrp
->e_phnum
;
1138 for (count
= 0; count
< num
; count
++)
1140 Elf_External_Phdr x_phdr
;
1141 elf_swap_phdr_out (abfd
, &i_phdrp
[count
], &x_phdr
);
1142 (*process
) (&x_phdr
, sizeof x_phdr
, arg
);
1145 num
= elf_numsections (abfd
);
1146 for (count
= 0; count
< num
; count
++)
1148 Elf_Internal_Shdr i_shdr
;
1149 Elf_External_Shdr x_shdr
;
1150 bfd_byte
*contents
, *free_contents
;
1152 i_shdr
= *i_shdrp
[count
];
1153 i_shdr
.sh_offset
= 0;
1155 elf_swap_shdr_out (abfd
, &i_shdr
, &x_shdr
);
1156 (*process
) (&x_shdr
, sizeof x_shdr
, arg
);
1158 /* Process the section's contents, if it has some.
1159 PR ld/12451: Read them in if necessary. */
1160 if (i_shdr
.sh_type
== SHT_NOBITS
)
1162 free_contents
= NULL
;
1163 contents
= i_shdr
.contents
;
1164 if (contents
== NULL
)
1168 sec
= bfd_section_from_elf_index (abfd
, count
);
1171 contents
= sec
->contents
;
1172 if (contents
== NULL
)
1174 /* Force rereading from file. */
1175 sec
->flags
&= ~SEC_IN_MEMORY
;
1176 if (!bfd_malloc_and_get_section (abfd
, sec
, &free_contents
))
1178 contents
= free_contents
;
1182 if (contents
!= NULL
)
1184 (*process
) (contents
, i_shdr
.sh_size
, arg
);
1185 free (free_contents
);
1193 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bool dynamic
)
1195 Elf_Internal_Shdr
*hdr
;
1196 Elf_Internal_Shdr
*verhdr
;
1197 unsigned long symcount
; /* Number of external ELF symbols */
1198 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1199 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1200 Elf_Internal_Sym
*isym
;
1201 Elf_Internal_Sym
*isymend
;
1202 Elf_Internal_Sym
*isymbuf
= NULL
;
1203 Elf_External_Versym
*xver
;
1204 Elf_External_Versym
*xverbuf
= NULL
;
1205 const struct elf_backend_data
*ebd
;
1208 /* Read each raw ELF symbol, converting from external ELF form to
1209 internal ELF form, and then using the information to create a
1210 canonical bfd symbol table entry.
1212 Note that we allocate the initial bfd canonical symbol buffer
1213 based on a one-to-one mapping of the ELF symbols to canonical
1214 symbols. We actually use all the ELF symbols, so there will be no
1215 space left over at the end. When we have all the symbols, we
1216 build the caller's pointer vector. */
1220 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1225 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1226 if (elf_dynversym (abfd
) == 0)
1229 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1230 if ((elf_dynverdef (abfd
) != 0
1231 && elf_tdata (abfd
)->verdef
== NULL
)
1232 || (elf_dynverref (abfd
) != 0
1233 && elf_tdata (abfd
)->verref
== NULL
))
1235 if (!_bfd_elf_slurp_version_tables (abfd
, false))
1240 ebd
= get_elf_backend_data (abfd
);
1241 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1243 sym
= symbase
= NULL
;
1246 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1248 if (isymbuf
== NULL
)
1251 if (_bfd_mul_overflow (symcount
, sizeof (elf_symbol_type
), &amt
))
1253 bfd_set_error (bfd_error_file_too_big
);
1256 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1257 if (symbase
== (elf_symbol_type
*) NULL
)
1260 /* Read the raw ELF version symbol information. */
1262 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1265 /* xgettext:c-format */
1266 (_("%pB: version count (%" PRId64
")"
1267 " does not match symbol count (%ld)"),
1269 (int64_t) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1272 /* Slurp in the symbols without the version information,
1273 since that is more helpful than just quitting. */
1279 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1281 xverbuf
= (Elf_External_Versym
*)
1282 _bfd_malloc_and_read (abfd
, verhdr
->sh_size
, verhdr
->sh_size
);
1283 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1287 /* Skip first symbol, which is a null dummy. */
1291 isymend
= isymbuf
+ symcount
;
1292 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1294 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1296 sym
->symbol
.the_bfd
= abfd
;
1297 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1298 sym
->symbol
.value
= isym
->st_value
;
1300 if (isym
->st_shndx
== SHN_UNDEF
)
1302 sym
->symbol
.section
= bfd_und_section_ptr
;
1304 else if (isym
->st_shndx
== SHN_ABS
)
1306 sym
->symbol
.section
= bfd_abs_section_ptr
;
1308 else if (isym
->st_shndx
== SHN_COMMON
)
1310 sym
->symbol
.section
= bfd_com_section_ptr
;
1311 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
1313 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
1317 flagword flags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
1319 xc
= bfd_make_section_with_flags (abfd
, "COMMON", flags
);
1323 sym
->symbol
.section
= xc
;
1325 /* Elf puts the alignment into the `value' field, and
1326 the size into the `size' field. BFD wants to see the
1327 size in the value field, and doesn't care (at the
1328 moment) about the alignment. */
1329 sym
->symbol
.value
= isym
->st_size
;
1334 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1335 if (sym
->symbol
.section
== NULL
)
1337 /* This symbol is in a section for which we did not
1338 create a BFD section. Just use bfd_abs_section,
1339 although it is wrong. FIXME. Note - there is
1340 code in elf.c:swap_out_syms that calls
1341 symbol_section_index() in the elf backend for
1343 sym
->symbol
.section
= bfd_abs_section_ptr
;
1347 /* If this is a relocatable file, then the symbol value is
1348 already section relative. */
1349 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1350 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1352 switch (ELF_ST_BIND (isym
->st_info
))
1355 sym
->symbol
.flags
|= BSF_LOCAL
;
1358 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1359 sym
->symbol
.flags
|= BSF_GLOBAL
;
1362 sym
->symbol
.flags
|= BSF_WEAK
;
1364 case STB_GNU_UNIQUE
:
1365 sym
->symbol
.flags
|= BSF_GNU_UNIQUE
;
1369 switch (ELF_ST_TYPE (isym
->st_info
))
1372 /* Mark the input section symbol as used since it may be
1373 used for relocation and section group.
1374 NB: BSF_SECTION_SYM_USED is ignored by linker and may
1375 be cleared by objcopy for non-relocatable inputs. */
1376 sym
->symbol
.flags
|= (BSF_SECTION_SYM
1378 | BSF_SECTION_SYM_USED
);
1381 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1384 sym
->symbol
.flags
|= BSF_FUNCTION
;
1387 /* FIXME: Do we have to put the size field into the value field
1388 as we do with symbols in SHN_COMMON sections (see above) ? */
1389 sym
->symbol
.flags
|= BSF_ELF_COMMON
;
1392 sym
->symbol
.flags
|= BSF_OBJECT
;
1395 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1398 sym
->symbol
.flags
|= BSF_RELC
;
1401 sym
->symbol
.flags
|= BSF_SRELC
;
1404 sym
->symbol
.flags
|= BSF_GNU_INDIRECT_FUNCTION
;
1409 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1413 Elf_Internal_Versym iversym
;
1415 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1416 sym
->version
= iversym
.vs_vers
;
1420 /* Do some backend-specific processing on this symbol. */
1421 if (ebd
->elf_backend_symbol_processing
)
1422 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1426 /* Do some backend-specific processing on this symbol table. */
1427 if (ebd
->elf_backend_symbol_table_processing
)
1428 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1430 /* We rely on the zalloc to clear out the final symbol entry. */
1432 symcount
= sym
- symbase
;
1434 /* Fill in the user's symbol pointer vector if needed. */
1442 *symptrs
++ = &sym
->symbol
;
1445 *symptrs
= 0; /* Final null pointer */
1449 if (hdr
->contents
!= (unsigned char *) isymbuf
)
1455 if (hdr
->contents
!= (unsigned char *) isymbuf
)
1460 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1464 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1466 Elf_Internal_Shdr
*rel_hdr
,
1467 bfd_size_type reloc_count
,
1472 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1473 void *allocated
= NULL
;
1474 bfd_byte
*native_relocs
;
1478 unsigned int symcount
;
1480 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1482 allocated
= _bfd_malloc_and_read (abfd
, rel_hdr
->sh_size
, rel_hdr
->sh_size
);
1483 if (allocated
== NULL
)
1486 native_relocs
= (bfd_byte
*) allocated
;
1488 entsize
= rel_hdr
->sh_entsize
;
1489 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1490 || entsize
== sizeof (Elf_External_Rela
));
1493 symcount
= bfd_get_dynamic_symcount (abfd
);
1495 symcount
= bfd_get_symcount (abfd
);
1497 for (i
= 0, relent
= relents
;
1499 i
++, relent
++, native_relocs
+= entsize
)
1502 Elf_Internal_Rela rela
;
1504 if (entsize
== sizeof (Elf_External_Rela
))
1505 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1507 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1509 /* The address of an ELF reloc is section relative for an object
1510 file, and absolute for an executable file or shared library.
1511 The address of a normal BFD reloc is always section relative,
1512 and the address of a dynamic reloc is absolute.. */
1513 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1514 relent
->address
= rela
.r_offset
;
1516 relent
->address
= rela
.r_offset
- asect
->vma
;
1518 if (ELF_R_SYM (rela
.r_info
) == STN_UNDEF
)
1519 /* FIXME: This and the error case below mean that we have a
1520 symbol on relocs that is not elf_symbol_type. */
1521 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1522 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1525 /* xgettext:c-format */
1526 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
1527 abfd
, asect
, i
, (long) ELF_R_SYM (rela
.r_info
));
1528 bfd_set_error (bfd_error_bad_value
);
1529 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1535 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1537 relent
->sym_ptr_ptr
= ps
;
1540 relent
->addend
= rela
.r_addend
;
1542 if ((entsize
== sizeof (Elf_External_Rela
)
1543 && ebd
->elf_info_to_howto
!= NULL
)
1544 || ebd
->elf_info_to_howto_rel
== NULL
)
1545 res
= ebd
->elf_info_to_howto (abfd
, relent
, &rela
);
1547 res
= ebd
->elf_info_to_howto_rel (abfd
, relent
, &rela
);
1549 if (! res
|| relent
->howto
== NULL
)
1561 /* Read in and swap the external relocs. */
1564 elf_slurp_reloc_table (bfd
*abfd
,
1569 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
1570 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1571 Elf_Internal_Shdr
*rel_hdr
;
1572 Elf_Internal_Shdr
*rel_hdr2
;
1573 bfd_size_type reloc_count
;
1574 bfd_size_type reloc_count2
;
1578 if (asect
->relocation
!= NULL
)
1583 if ((asect
->flags
& SEC_RELOC
) == 0
1584 || asect
->reloc_count
== 0)
1587 rel_hdr
= d
->rel
.hdr
;
1588 reloc_count
= rel_hdr
? NUM_SHDR_ENTRIES (rel_hdr
) : 0;
1589 rel_hdr2
= d
->rela
.hdr
;
1590 reloc_count2
= rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0;
1592 /* PR 17512: file: 0b4f81b7. */
1593 if (asect
->reloc_count
!= reloc_count
+ reloc_count2
)
1595 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
1596 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1601 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1602 case because relocations against this section may use the
1603 dynamic symbol table, and in that case bfd_section_from_shdr
1604 in elf.c does not update the RELOC_COUNT. */
1605 if (asect
->size
== 0)
1608 rel_hdr
= &d
->this_hdr
;
1609 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1614 if (_bfd_mul_overflow (reloc_count
+ reloc_count2
, sizeof (arelent
), &amt
))
1616 bfd_set_error (bfd_error_file_too_big
);
1619 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1620 if (relents
== NULL
)
1624 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1625 rel_hdr
, reloc_count
,
1631 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1632 rel_hdr2
, reloc_count2
,
1633 relents
+ reloc_count
,
1637 if (!bed
->slurp_secondary_relocs (abfd
, asect
, symbols
, dynamic
))
1640 asect
->relocation
= relents
;
1646 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1648 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1649 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1652 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1653 (long) hdr
->sh_name
,
1654 (long) hdr
->sh_type
,
1655 (long) hdr
->sh_flags
);
1657 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1658 (long) hdr
->sh_addr
,
1659 (long) hdr
->sh_offset
,
1660 (long) hdr
->sh_size
);
1662 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1663 (long) hdr
->sh_link
,
1664 (long) hdr
->sh_info
,
1665 (long) hdr
->sh_addralign
);
1666 fprintf (stderr
, "sh_entsize = %ld\n",
1667 (long) hdr
->sh_entsize
);
1674 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1676 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1677 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1678 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1679 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1680 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1681 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1682 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1686 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1687 reconstruct an ELF file by reading the segments out of remote
1688 memory based on the ELF file header at EHDR_VMA and the ELF program
1689 headers it points to. If non-zero, SIZE is the known extent of the
1690 object. If not null, *LOADBASEP is filled in with the difference
1691 between the VMAs from which the segments were read, and the VMAs
1692 the file headers (and hence BFD's idea of each section's VMA) put
1695 The function TARGET_READ_MEMORY is called to copy LEN bytes from
1696 the remote memory at target address VMA into the local buffer at
1697 MYADDR; it should return zero on success or an `errno' code on
1698 failure. TEMPL must be a BFD for a target with the word size and
1699 byte order found in the remote memory. */
1702 NAME(_bfd_elf
,bfd_from_remote_memory
)
1704 bfd_vma ehdr_vma
/* Bytes. */,
1705 bfd_size_type size
/* Octets. */,
1706 bfd_vma
*loadbasep
/* Bytes. */,
1707 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
1708 /* (Bytes , , octets ). */
1710 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1711 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1712 Elf_External_Phdr
*x_phdrs
;
1713 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
, *first_phdr
;
1715 struct bfd_in_memory
*bim
;
1719 bfd_vma high_offset
;
1721 bfd_vma loadbase
; /* Bytes. */
1723 unsigned int opb
= bfd_octets_per_byte (templ
, NULL
);
1725 /* Read in the ELF header in external format. */
1726 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1729 bfd_set_error (bfd_error_system_call
);
1734 /* Now check to see if we have a valid ELF file, and one that BFD can
1735 make use of. The magic number must match, the address size ('class')
1736 and byte-swapping must match our XVEC entry. */
1738 if (! elf_file_p (&x_ehdr
)
1739 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1740 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1742 bfd_set_error (bfd_error_wrong_format
);
1746 /* Check that file's byte order matches xvec's */
1747 switch (x_ehdr
.e_ident
[EI_DATA
])
1749 case ELFDATA2MSB
: /* Big-endian */
1750 if (! bfd_header_big_endian (templ
))
1752 bfd_set_error (bfd_error_wrong_format
);
1756 case ELFDATA2LSB
: /* Little-endian */
1757 if (! bfd_header_little_endian (templ
))
1759 bfd_set_error (bfd_error_wrong_format
);
1763 case ELFDATANONE
: /* No data encoding specified */
1764 default: /* Unknown data encoding specified */
1765 bfd_set_error (bfd_error_wrong_format
);
1769 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1771 /* The file header tells where to find the program headers.
1772 These are what we use to actually choose what to read. */
1774 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1776 bfd_set_error (bfd_error_wrong_format
);
1780 if (_bfd_mul_overflow (i_ehdr
.e_phnum
,
1781 sizeof (*x_phdrs
) + sizeof (*i_phdrs
), &amt
))
1783 bfd_set_error (bfd_error_file_too_big
);
1786 x_phdrs
= (Elf_External_Phdr
*) bfd_malloc (amt
);
1787 if (x_phdrs
== NULL
)
1789 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1790 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1794 bfd_set_error (bfd_error_system_call
);
1798 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1804 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1806 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1807 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1809 bfd_vma segment_end
= i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
;
1811 if (segment_end
> high_offset
)
1813 high_offset
= segment_end
;
1814 last_phdr
= &i_phdrs
[i
];
1817 /* If this program header covers offset zero, where the file
1818 header sits, then we can figure out the loadbase. */
1819 if (first_phdr
== NULL
)
1821 bfd_vma p_offset
= i_phdrs
[i
].p_offset
; /* Octets. */
1822 bfd_vma p_vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1824 if (i_phdrs
[i
].p_align
> 1)
1826 p_offset
&= -(i_phdrs
[i
].p_align
* opb
);
1827 p_vaddr
&= -(i_phdrs
[i
].p_align
* opb
);
1831 loadbase
= ehdr_vma
- p_vaddr
/ opb
;
1832 first_phdr
= &i_phdrs
[i
];
1837 if (high_offset
== 0)
1839 /* There were no PT_LOAD segments, so we don't have anything to read. */
1841 bfd_set_error (bfd_error_wrong_format
);
1846 if (i_ehdr
.e_shoff
!= 0 && i_ehdr
.e_shnum
!= 0 && i_ehdr
.e_shentsize
!= 0)
1848 shdr_end
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1850 if (last_phdr
->p_filesz
!= last_phdr
->p_memsz
)
1852 /* If the last PT_LOAD header has a bss area then ld.so will
1853 have cleared anything past p_filesz, zapping the section
1856 else if (size
>= shdr_end
)
1860 bfd_vma page_size
= get_elf_backend_data (templ
)->minpagesize
;
1861 bfd_vma segment_end
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1863 /* Assume we loaded full pages, allowing us to sometimes see
1865 if (page_size
> 1 && shdr_end
> segment_end
)
1867 bfd_vma page_end
= (segment_end
+ page_size
- 1) & -page_size
;
1869 if (page_end
>= shdr_end
)
1870 /* Whee, section headers covered. */
1871 high_offset
= shdr_end
;
1876 /* Now we know the size of the whole image we want read in. */
1877 contents
= (bfd_byte
*) bfd_zmalloc (high_offset
);
1878 if (contents
== NULL
)
1884 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1885 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1887 bfd_vma start
= i_phdrs
[i
].p_offset
; /* Octets. */
1888 bfd_vma end
= start
+ i_phdrs
[i
].p_filesz
; /* Octets. */
1889 bfd_vma vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1891 /* Extend the beginning of the first pt_load to cover file
1892 header and program headers, if we proved earlier that its
1893 aligned offset is 0. */
1894 if (first_phdr
== &i_phdrs
[i
])
1899 /* Extend the end of the last pt_load to cover section headers. */
1900 if (last_phdr
== &i_phdrs
[i
])
1902 err
= target_read_memory (loadbase
+ vaddr
/ opb
,
1903 contents
+ start
, end
- start
);
1908 bfd_set_error (bfd_error_system_call
);
1915 /* If the segments visible in memory didn't include the section headers,
1916 then clear them from the file header. */
1917 if (high_offset
< shdr_end
)
1919 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1920 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1921 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1924 /* This will normally have been in the first PT_LOAD segment. But it
1925 conceivably could be missing, and we might have just changed it. */
1926 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1928 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1929 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1935 nbfd
= _bfd_new_bfd ();
1937 || !bfd_set_filename (nbfd
, "<in-memory>"))
1943 nbfd
->xvec
= templ
->xvec
;
1944 bim
->size
= high_offset
;
1945 bim
->buffer
= contents
;
1946 nbfd
->iostream
= bim
;
1947 nbfd
->flags
= BFD_IN_MEMORY
;
1948 nbfd
->iovec
= &_bfd_memory_iovec
;
1950 nbfd
->direction
= read_direction
;
1951 nbfd
->mtime
= time (NULL
);
1952 nbfd
->mtime_set
= true;
1955 *loadbasep
= loadbase
;
1959 /* Function for ELF_R_INFO. */
1962 NAME(elf
,r_info
) (bfd_vma sym
, bfd_vma type
)
1964 return ELF_R_INFO (sym
, type
);
1967 /* Function for ELF_R_SYM. */
1970 NAME(elf
,r_sym
) (bfd_vma r_info
)
1972 return ELF_R_SYM (r_info
);
1975 #include "elfcore.h"
1977 /* Size-dependent data and functions. */
1978 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1979 sizeof (Elf_External_Ehdr
),
1980 sizeof (Elf_External_Phdr
),
1981 sizeof (Elf_External_Shdr
),
1982 sizeof (Elf_External_Rel
),
1983 sizeof (Elf_External_Rela
),
1984 sizeof (Elf_External_Sym
),
1985 sizeof (Elf_External_Dyn
),
1986 sizeof (Elf_External_Note
),
1989 ARCH_SIZE
, LOG_FILE_ALIGN
,
1990 ELFCLASS
, EV_CURRENT
,
1991 elf_write_out_phdrs
,
1992 elf_write_shdrs_and_ehdr
,
1993 elf_checksum_contents
,
1996 elf_swap_symbol_out
,
1997 elf_slurp_reloc_table
,
1998 elf_slurp_symbol_table
,