1 /* ELF executable support for BFD.
2 Copyright (C) 1991-2023 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 bool no_section_header
= (abfd
->flags
& BFD_NO_SECTION_HEADER
) != 0;
270 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
271 /* note that all elements of dst are *arrays of unsigned char* already... */
272 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
273 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
274 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
276 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
278 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
279 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
280 if (no_section_header
)
281 H_PUT_WORD (abfd
, 0, dst
->e_shoff
);
283 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
284 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
285 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
286 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
290 H_PUT_16 (abfd
, tmp
, dst
->e_phnum
);
291 if (no_section_header
)
293 H_PUT_16 (abfd
, 0, dst
->e_shentsize
);
294 H_PUT_16 (abfd
, 0, dst
->e_shnum
);
295 H_PUT_16 (abfd
, 0, dst
->e_shstrndx
);
299 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
301 if (tmp
>= (SHN_LORESERVE
& 0xffff))
303 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
304 tmp
= src
->e_shstrndx
;
305 if (tmp
>= (SHN_LORESERVE
& 0xffff))
306 tmp
= SHN_XINDEX
& 0xffff;
307 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
311 /* Translate an ELF section header table entry in external format into an
312 ELF section header table entry in internal format. */
315 elf_swap_shdr_in (bfd
*abfd
,
316 const Elf_External_Shdr
*src
,
317 Elf_Internal_Shdr
*dst
)
319 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
321 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
322 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
323 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
325 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
327 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
328 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
329 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
330 /* PR 23657. Check for invalid section size, in sections with contents.
331 Note - we do not set an error value here because the contents
332 of this particular section might not be needed by the consumer. */
333 if (dst
->sh_type
!= SHT_NOBITS
)
335 ufile_ptr filesize
= bfd_get_file_size (abfd
);
338 && ((ufile_ptr
) dst
->sh_offset
> filesize
339 || dst
->sh_size
> filesize
- dst
->sh_offset
)
342 _bfd_error_handler (_("warning: %pB has a section "
343 "extending past end of file"), abfd
);
347 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
348 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
349 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
350 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
351 dst
->bfd_section
= NULL
;
352 dst
->contents
= NULL
;
355 /* Translate an ELF section header table entry in internal format into an
356 ELF section header table entry in external format. */
359 elf_swap_shdr_out (bfd
*abfd
,
360 const Elf_Internal_Shdr
*src
,
361 Elf_External_Shdr
*dst
)
363 /* note that all elements of dst are *arrays of unsigned char* already... */
364 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
365 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
366 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
367 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
368 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
369 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
370 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
371 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
372 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
373 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
376 /* Translate an ELF program header table entry in external format into an
377 ELF program header table entry in internal format. */
380 elf_swap_phdr_in (bfd
*abfd
,
381 const Elf_External_Phdr
*src
,
382 Elf_Internal_Phdr
*dst
)
384 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
386 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
387 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
388 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
391 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
392 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
396 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
397 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
399 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
400 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
401 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
405 elf_swap_phdr_out (bfd
*abfd
,
406 const Elf_Internal_Phdr
*src
,
407 Elf_External_Phdr
*dst
)
409 const struct elf_backend_data
*bed
;
412 bed
= get_elf_backend_data (abfd
);
413 p_paddr
= bed
->want_p_paddr_set_to_zero
? 0 : src
->p_paddr
;
415 /* note that all elements of dst are *arrays of unsigned char* already... */
416 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
417 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
418 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
419 H_PUT_WORD (abfd
, p_paddr
, dst
->p_paddr
);
420 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
421 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
422 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
423 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
426 /* Translate an ELF reloc from external format to internal format. */
428 elf_swap_reloc_in (bfd
*abfd
,
430 Elf_Internal_Rela
*dst
)
432 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
433 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
434 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
439 elf_swap_reloca_in (bfd
*abfd
,
441 Elf_Internal_Rela
*dst
)
443 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
444 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
445 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
446 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
449 /* Translate an ELF reloc from internal format to external format. */
451 elf_swap_reloc_out (bfd
*abfd
,
452 const Elf_Internal_Rela
*src
,
455 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
456 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
457 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
461 elf_swap_reloca_out (bfd
*abfd
,
462 const Elf_Internal_Rela
*src
,
465 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
466 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
467 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
468 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
472 elf_swap_dyn_in (bfd
*abfd
,
474 Elf_Internal_Dyn
*dst
)
476 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
478 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
479 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
483 elf_swap_dyn_out (bfd
*abfd
,
484 const Elf_Internal_Dyn
*src
,
487 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
489 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
490 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
493 /* ELF .o/exec file reading */
495 /* Begin processing a given object.
497 First we validate the file by reading in the ELF header and checking
501 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
503 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
504 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
505 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
506 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
509 /* Check to see if the file associated with ABFD matches the target vector
512 Note that we may be called several times with the same ABFD, but different
513 target vectors, most of which will not match. We have to avoid leaving
514 any side effects in ABFD, or any data it points to (like tdata), if the
515 file does not match the target vector. */
518 elf_object_p (bfd
*abfd
)
520 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
521 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
522 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
523 Elf_Internal_Shdr i_shdr
;
524 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
525 unsigned int shindex
;
526 const struct elf_backend_data
*ebd
;
528 const bfd_target
*target
;
530 /* Read in the ELF header in external format. */
532 if (bfd_read (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
534 if (bfd_get_error () != bfd_error_system_call
)
535 goto got_wrong_format_error
;
540 /* Now check to see if we have a valid ELF file, and one that BFD can
541 make use of. The magic number must match, the address size ('class')
542 and byte-swapping must match our XVEC entry, and it must have a
543 section header table (FIXME: See comments re sections at top of this
546 if (! elf_file_p (&x_ehdr
)
547 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
548 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
549 goto got_wrong_format_error
;
551 /* Check that file's byte order matches xvec's */
552 switch (x_ehdr
.e_ident
[EI_DATA
])
554 case ELFDATA2MSB
: /* Big-endian */
555 if (! bfd_header_big_endian (abfd
))
556 goto got_wrong_format_error
;
558 case ELFDATA2LSB
: /* Little-endian */
559 if (! bfd_header_little_endian (abfd
))
560 goto got_wrong_format_error
;
562 case ELFDATANONE
: /* No data encoding specified */
563 default: /* Unknown data encoding specified */
564 goto got_wrong_format_error
;
569 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
570 the tdata pointer in the bfd. */
572 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
575 /* Now that we know the byte order, swap in the rest of the header */
576 i_ehdrp
= elf_elfheader (abfd
);
577 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
579 elf_debug_file (i_ehdrp
);
582 /* Reject ET_CORE (header indicates core file, not object file) */
583 if (i_ehdrp
->e_type
== ET_CORE
)
584 goto got_wrong_format_error
;
586 /* If this is a relocatable file and there is no section header
587 table, then we're hosed. */
588 if (i_ehdrp
->e_shoff
< sizeof (x_ehdr
) && i_ehdrp
->e_type
== ET_REL
)
589 goto got_wrong_format_error
;
591 /* As a simple sanity check, verify that what BFD thinks is the
592 size of each section header table entry actually matches the size
593 recorded in the file, but only if there are any sections. */
594 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
595 goto got_wrong_format_error
;
597 /* Further sanity check. */
598 if (i_ehdrp
->e_shoff
< sizeof (x_ehdr
) && i_ehdrp
->e_shnum
!= 0)
599 goto got_wrong_format_error
;
601 ebd
= get_elf_backend_data (abfd
);
602 if (ebd
->s
->arch_size
!= ARCH_SIZE
)
603 goto got_wrong_format_error
;
605 /* Check that the ELF e_machine field matches what this particular
606 BFD format expects. */
607 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
608 && (ebd
->elf_machine_alt1
== 0
609 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
610 && (ebd
->elf_machine_alt2
== 0
611 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
)
612 && ebd
->elf_machine_code
!= EM_NONE
)
613 goto got_wrong_format_error
;
615 if (i_ehdrp
->e_type
== ET_EXEC
)
616 abfd
->flags
|= EXEC_P
;
617 else if (i_ehdrp
->e_type
== ET_DYN
)
618 abfd
->flags
|= DYNAMIC
;
620 if (i_ehdrp
->e_phnum
> 0)
621 abfd
->flags
|= D_PAGED
;
623 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
625 /* It's OK if this fails for the generic target. */
626 if (ebd
->elf_machine_code
!= EM_NONE
)
630 if (ebd
->elf_machine_code
!= EM_NONE
631 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
632 && ebd
->elf_osabi
!= ELFOSABI_NONE
)
633 goto got_wrong_format_error
;
635 if (i_ehdrp
->e_shoff
>= sizeof (x_ehdr
))
637 file_ptr where
= (file_ptr
) i_ehdrp
->e_shoff
;
639 /* Seek to the section header table in the file. */
640 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
643 /* Read the first section header at index 0, and convert to internal
645 if (bfd_read (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
647 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
649 /* If the section count is zero, the actual count is in the first
651 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
653 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
654 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
655 || i_ehdrp
->e_shnum
!= i_shdr
.sh_size
656 || i_ehdrp
->e_shnum
== 0)
657 goto got_wrong_format_error
;
660 /* And similarly for the string table index. */
661 if (i_ehdrp
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
663 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
664 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
665 goto got_wrong_format_error
;
668 /* And program headers. */
669 if (i_ehdrp
->e_phnum
== PN_XNUM
&& i_shdr
.sh_info
!= 0)
671 i_ehdrp
->e_phnum
= i_shdr
.sh_info
;
672 if (i_ehdrp
->e_phnum
!= i_shdr
.sh_info
)
673 goto got_wrong_format_error
;
676 /* Sanity check that we can read all of the section headers.
677 It ought to be good enough to just read the last one. */
678 if (i_ehdrp
->e_shnum
!= 1)
680 /* Check that we don't have a totally silly number of sections. */
681 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
682 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
683 goto got_wrong_format_error
;
685 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
686 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
687 goto got_wrong_format_error
;
689 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
691 if (bfd_read (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
694 /* Back to where we were. */
695 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
696 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
701 /* Allocate space for a copy of the section header table in
703 if (i_ehdrp
->e_shnum
!= 0)
705 Elf_Internal_Shdr
*shdrp
;
706 unsigned int num_sec
;
709 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*i_shdrp
), &amt
))
710 goto got_wrong_format_error
;
711 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
714 num_sec
= i_ehdrp
->e_shnum
;
715 elf_numsections (abfd
) = num_sec
;
716 if (_bfd_mul_overflow (num_sec
, sizeof (i_shdrp
), &amt
))
717 goto got_wrong_format_error
;
718 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
719 if (!elf_elfsections (abfd
))
721 elf_tdata (abfd
)->being_created
= bfd_zalloc (abfd
, num_sec
);
722 if (!elf_tdata (abfd
)->being_created
)
725 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
726 for (shdrp
= i_shdrp
, shindex
= 0; shindex
< num_sec
; shindex
++)
727 elf_elfsections (abfd
)[shindex
] = shdrp
++;
729 /* Read in the rest of the section header table and convert it
731 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
733 if (bfd_read (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
735 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
737 /* Sanity check sh_link and sh_info. */
738 if (i_shdrp
[shindex
].sh_link
>= num_sec
)
740 /* PR 10478: Accept Solaris binaries with a sh_link
741 field set to SHN_BEFORE or SHN_AFTER. */
742 switch (ebd
->elf_machine_code
)
751 if (i_shdrp
[shindex
].sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
752 || i_shdrp
[shindex
].sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
754 /* Otherwise fall through. */
756 goto got_wrong_format_error
;
760 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
761 || i_shdrp
[shindex
].sh_type
== SHT_RELA
762 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
763 && i_shdrp
[shindex
].sh_info
>= num_sec
)
764 goto got_wrong_format_error
;
766 /* If the section is loaded, but not page aligned, clear
768 if (i_shdrp
[shindex
].sh_size
!= 0
769 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
770 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
771 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
774 abfd
->flags
&= ~D_PAGED
;
777 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
)
778 || i_shdrp
[i_ehdrp
->e_shstrndx
].sh_type
!= SHT_STRTAB
)
781 We used to just goto got_wrong_format_error here
782 but there are binaries in existance for which this test
783 will prevent the binutils from working with them at all.
784 So we are kind, and reset the string index value to 0
785 so that at least some processing can be done. */
786 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
787 if (!abfd
->read_only
)
790 (_("warning: %pB has a corrupt string table index"), abfd
);
795 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
796 goto got_wrong_format_error
;
798 /* Read in the program headers. */
799 if (i_ehdrp
->e_phnum
== 0)
800 elf_tdata (abfd
)->phdr
= NULL
;
803 Elf_Internal_Phdr
*i_phdr
;
808 /* Check for a corrupt input file with an impossibly large number
809 of program headers. */
810 filesize
= bfd_get_file_size (abfd
);
812 && i_ehdrp
->e_phnum
> filesize
/ sizeof (Elf_External_Phdr
))
813 goto got_wrong_format_error
;
814 if (_bfd_mul_overflow (i_ehdrp
->e_phnum
, sizeof (*i_phdr
), &amt
))
815 goto got_wrong_format_error
;
816 elf_tdata (abfd
)->phdr
817 = (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
818 if (elf_tdata (abfd
)->phdr
== NULL
)
820 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
822 bool eu_strip_broken_phdrs
= false;
823 i_phdr
= elf_tdata (abfd
)->phdr
;
824 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
826 Elf_External_Phdr x_phdr
;
828 if (bfd_read (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
830 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
831 /* Too much code in BFD relies on alignment being a power of
832 two, as required by the ELF spec. */
833 if (i_phdr
->p_align
!= (i_phdr
->p_align
& -i_phdr
->p_align
))
835 i_phdr
->p_align
&= -i_phdr
->p_align
;
836 if (!abfd
->read_only
)
838 _bfd_error_handler (_("warning: %pB has a program header "
839 "with invalid alignment"), abfd
);
843 /* Detect eu-strip -f debug files, which have program
844 headers that describe the original file. */
845 if (i_phdr
->p_filesz
!= 0
846 && (i_phdr
->p_filesz
> filesize
847 || i_phdr
->p_offset
> filesize
- i_phdr
->p_filesz
))
848 eu_strip_broken_phdrs
= true;
850 if (!eu_strip_broken_phdrs
851 && i_ehdrp
->e_shoff
== 0
852 && i_ehdrp
->e_shstrndx
== 0)
854 /* Try to reconstruct dynamic symbol table from PT_DYNAMIC
855 segment if there is no section header. */
856 i_phdr
= elf_tdata (abfd
)->phdr
;
857 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
858 if (i_phdr
->p_type
== PT_DYNAMIC
)
860 if (i_phdr
->p_filesz
!= 0
861 && !_bfd_elf_get_dynamic_symbols (abfd
, i_phdr
,
862 elf_tdata (abfd
)->phdr
,
871 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
>= sizeof (x_ehdr
))
873 unsigned int num_sec
;
875 /* Once all of the section headers have been read and converted, we
876 can start processing them. Note that the first section header is
877 a dummy placeholder entry, so we ignore it. */
878 num_sec
= elf_numsections (abfd
);
879 for (shindex
= 1; shindex
< num_sec
; shindex
++)
880 if (!bfd_section_from_shdr (abfd
, shindex
))
883 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
884 if (! _bfd_elf_setup_sections (abfd
))
885 goto got_wrong_format_error
;
888 /* Let the backend double check the format and override global
890 if (ebd
->elf_backend_object_p
)
892 if (! (*ebd
->elf_backend_object_p
) (abfd
))
893 goto got_wrong_format_error
;
896 /* Remember the entry point specified in the ELF file header. */
897 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
899 /* If we have created any reloc sections that are associated with
900 debugging sections, mark the reloc sections as debugging as well. */
901 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
903 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
904 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
905 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
907 unsigned long targ_index
;
910 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
911 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
913 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
914 s
->flags
|= SEC_DEBUGGING
;
917 return _bfd_no_cleanup
;
919 got_wrong_format_error
:
920 bfd_set_error (bfd_error_wrong_format
);
926 /* ELF .o/exec file writing */
928 /* Write out the relocs. */
931 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
933 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
934 bool *failedp
= (bool *) data
;
935 Elf_Internal_Shdr
*rela_hdr
;
937 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
945 /* If we have already failed, don't do anything. */
949 if ((sec
->flags
& SEC_RELOC
) == 0)
952 /* The linker backend writes the relocs out itself, and sets the
953 reloc_count field to zero to inhibit writing them here. Also,
954 sometimes the SEC_RELOC flag gets set even when there aren't any
956 if (sec
->reloc_count
== 0)
959 /* If we have opened an existing file for update, reloc_count may be
960 set even though we are not linking. In that case we have nothing
962 if (sec
->orelocation
== NULL
)
965 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
966 if (rela_hdr
== NULL
)
967 rela_hdr
= elf_section_data (sec
)->rel
.hdr
;
969 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
970 if (_bfd_mul_overflow (sec
->reloc_count
, rela_hdr
->sh_entsize
, &amt
)
971 || (rela_hdr
->contents
= bfd_alloc (abfd
, amt
)) == NULL
)
973 bfd_set_error (bfd_error_no_memory
);
978 /* Figure out whether the relocations are RELA or REL relocations. */
979 if (rela_hdr
->sh_type
== SHT_RELA
)
981 swap_out
= elf_swap_reloca_out
;
982 extsize
= sizeof (Elf_External_Rela
);
984 else if (rela_hdr
->sh_type
== SHT_REL
)
986 swap_out
= elf_swap_reloc_out
;
987 extsize
= sizeof (Elf_External_Rel
);
990 /* Every relocation section should be either an SHT_RELA or an
994 /* The address of an ELF reloc is section relative for an object
995 file, and absolute for an executable file or shared library.
996 The address of a BFD reloc is always section relative. */
998 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
999 addr_offset
= sec
->vma
;
1001 /* orelocation has the data, reloc_count has the count... */
1004 dst_rela
= rela_hdr
->contents
;
1006 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
1008 Elf_Internal_Rela src_rela
;
1013 ptr
= sec
->orelocation
[idx
];
1014 sym
= *ptr
->sym_ptr_ptr
;
1015 if (sym
== last_sym
)
1017 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
1022 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
1031 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
1032 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
1033 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
1039 if (ptr
->howto
== NULL
)
1045 #if defined(BFD64) && ARCH_SIZE == 32
1046 if (rela_hdr
->sh_type
== SHT_RELA
1047 && ptr
->howto
->bitsize
> 32
1048 && ptr
->addend
- INT32_MIN
> UINT32_MAX
)
1050 _bfd_error_handler (_("%pB: %pA+%" PRIx64
": "
1051 "relocation addend %" PRIx64
" too large"),
1052 abfd
, sec
, (uint64_t) ptr
->address
,
1053 (uint64_t) ptr
->addend
);
1055 bfd_set_error (bfd_error_bad_value
);
1059 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
1060 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1061 src_rela
.r_addend
= ptr
->addend
;
1062 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
1065 if (elf_section_data (sec
)->has_secondary_relocs
1066 && !bed
->write_secondary_relocs (abfd
, sec
))
1073 /* Write out the program headers. */
1076 elf_write_out_phdrs (bfd
*abfd
,
1077 const Elf_Internal_Phdr
*phdr
,
1082 Elf_External_Phdr extphdr
;
1084 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1085 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
1086 != sizeof (Elf_External_Phdr
))
1093 /* Write out the section headers and the ELF file header. */
1096 elf_write_shdrs_and_ehdr (bfd
*abfd
)
1098 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1099 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1100 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1101 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1105 i_ehdrp
= elf_elfheader (abfd
);
1106 i_shdrp
= elf_elfsections (abfd
);
1108 /* swap the header before spitting it out... */
1111 elf_debug_file (i_ehdrp
);
1113 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1114 amt
= sizeof (x_ehdr
);
1115 if (bfd_seek (abfd
, 0, SEEK_SET
) != 0
1116 || bfd_write (&x_ehdr
, amt
, abfd
) != amt
)
1119 if ((abfd
->flags
& BFD_NO_SECTION_HEADER
) != 0)
1122 /* Some fields in the first section header handle overflow of ehdr
1124 if (i_ehdrp
->e_phnum
>= PN_XNUM
)
1125 i_shdrp
[0]->sh_info
= i_ehdrp
->e_phnum
;
1126 if (i_ehdrp
->e_shnum
>= (SHN_LORESERVE
& 0xffff))
1127 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1128 if (i_ehdrp
->e_shstrndx
>= (SHN_LORESERVE
& 0xffff))
1129 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1131 /* at this point we've concocted all the ELF sections... */
1132 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*x_shdrp
), &amt
))
1134 bfd_set_error (bfd_error_no_memory
);
1137 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1141 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1144 elf_debug_section (count
, *i_shdrp
);
1146 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1148 amt
= (bfd_size_type
) i_ehdrp
->e_shnum
* sizeof (*x_shdrp
);
1149 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1150 || bfd_write (x_shdrp
, amt
, abfd
) != amt
)
1153 /* need to dump the string table too... */
1159 elf_checksum_contents (bfd
*abfd
,
1160 void (*process
) (const void *, size_t, void *),
1163 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1164 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
1165 Elf_Internal_Phdr
*i_phdrp
= elf_tdata (abfd
)->phdr
;
1166 unsigned int count
, num
;
1169 Elf_External_Ehdr x_ehdr
;
1170 Elf_Internal_Ehdr i_ehdr
;
1173 i_ehdr
.e_phoff
= i_ehdr
.e_shoff
= 0;
1174 elf_swap_ehdr_out (abfd
, &i_ehdr
, &x_ehdr
);
1175 (*process
) (&x_ehdr
, sizeof x_ehdr
, arg
);
1178 num
= i_ehdrp
->e_phnum
;
1179 for (count
= 0; count
< num
; count
++)
1181 Elf_External_Phdr x_phdr
;
1182 elf_swap_phdr_out (abfd
, &i_phdrp
[count
], &x_phdr
);
1183 (*process
) (&x_phdr
, sizeof x_phdr
, arg
);
1186 num
= elf_numsections (abfd
);
1187 for (count
= 0; count
< num
; count
++)
1189 Elf_Internal_Shdr i_shdr
;
1190 Elf_External_Shdr x_shdr
;
1191 bfd_byte
*contents
, *free_contents
;
1193 i_shdr
= *i_shdrp
[count
];
1194 i_shdr
.sh_offset
= 0;
1196 elf_swap_shdr_out (abfd
, &i_shdr
, &x_shdr
);
1197 (*process
) (&x_shdr
, sizeof x_shdr
, arg
);
1199 /* Process the section's contents, if it has some.
1200 PR ld/12451: Read them in if necessary. */
1201 if (i_shdr
.sh_type
== SHT_NOBITS
)
1203 free_contents
= NULL
;
1204 contents
= i_shdr
.contents
;
1205 if (contents
== NULL
)
1209 sec
= bfd_section_from_elf_index (abfd
, count
);
1212 contents
= sec
->contents
;
1213 if (contents
== NULL
)
1215 /* Force rereading from file. */
1216 sec
->flags
&= ~SEC_IN_MEMORY
;
1217 if (!bfd_malloc_and_get_section (abfd
, sec
, &free_contents
))
1219 contents
= free_contents
;
1223 if (contents
!= NULL
)
1225 (*process
) (contents
, i_shdr
.sh_size
, arg
);
1226 free (free_contents
);
1234 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bool dynamic
)
1236 Elf_Internal_Shdr
*hdr
;
1237 Elf_Internal_Shdr
*verhdr
;
1238 unsigned long symcount
; /* Number of external ELF symbols */
1239 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1240 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1241 Elf_Internal_Sym
*isym
;
1242 Elf_Internal_Sym
*isymend
;
1243 Elf_Internal_Sym
*isymbuf
= NULL
;
1244 Elf_External_Versym
*xver
;
1245 Elf_External_Versym
*xverbuf
= NULL
;
1246 const struct elf_backend_data
*ebd
;
1249 /* Read each raw ELF symbol, converting from external ELF form to
1250 internal ELF form, and then using the information to create a
1251 canonical bfd symbol table entry.
1253 Note that we allocate the initial bfd canonical symbol buffer
1254 based on a one-to-one mapping of the ELF symbols to canonical
1255 symbols. We actually use all the ELF symbols, so there will be no
1256 space left over at the end. When we have all the symbols, we
1257 build the caller's pointer vector. */
1258 ebd
= get_elf_backend_data (abfd
);
1262 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1264 symcount
= hdr
->sh_size
/ ebd
->s
->sizeof_sym
;
1268 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1269 if (elf_dynversym (abfd
) == 0)
1272 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1273 if ((elf_dynverdef (abfd
) != 0
1274 && elf_tdata (abfd
)->verdef
== NULL
)
1275 || (elf_dynverref (abfd
) != 0
1276 && elf_tdata (abfd
)->verref
== NULL
)
1277 || elf_tdata (abfd
)->dt_verdef
!= NULL
1278 || elf_tdata (abfd
)->dt_verneed
!= NULL
)
1280 if (!_bfd_elf_slurp_version_tables (abfd
, false))
1284 symcount
= elf_tdata (abfd
)->dt_symtab_count
;
1288 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1291 sym
= symbase
= NULL
;
1296 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1298 if (isymbuf
== NULL
)
1301 if (_bfd_mul_overflow (symcount
, sizeof (elf_symbol_type
), &amt
))
1303 bfd_set_error (bfd_error_file_too_big
);
1306 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1307 if (symbase
== (elf_symbol_type
*) NULL
)
1310 /* Read the raw ELF version symbol information. */
1312 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1315 /* xgettext:c-format */
1316 (_("%pB: version count (%" PRId64
")"
1317 " does not match symbol count (%ld)"),
1319 (int64_t) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1322 /* Slurp in the symbols without the version information,
1323 since that is more helpful than just quitting. */
1329 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1331 xverbuf
= (Elf_External_Versym
*)
1332 _bfd_malloc_and_read (abfd
, verhdr
->sh_size
, verhdr
->sh_size
);
1333 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1337 /* Skip first symbol, which is a null dummy. */
1341 isymend
= isymbuf
+ symcount
;
1342 for (isym
= isymbuf
+ 1, sym
= symbase
, i
= 1;
1346 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1348 sym
->symbol
.the_bfd
= abfd
;
1349 if (elf_use_dt_symtab_p (abfd
))
1350 sym
->symbol
.name
= (elf_tdata (abfd
)->dt_strtab
1353 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1354 sym
->symbol
.value
= isym
->st_value
;
1356 if (isym
->st_shndx
== SHN_UNDEF
)
1358 sym
->symbol
.section
= bfd_und_section_ptr
;
1360 else if (isym
->st_shndx
== SHN_ABS
)
1362 sym
->symbol
.section
= bfd_abs_section_ptr
;
1364 else if (isym
->st_shndx
== SHN_COMMON
)
1366 sym
->symbol
.section
= bfd_com_section_ptr
;
1367 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
1369 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
1373 flagword flags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
1375 xc
= bfd_make_section_with_flags (abfd
, "COMMON", flags
);
1379 sym
->symbol
.section
= xc
;
1381 /* Elf puts the alignment into the `value' field, and
1382 the size into the `size' field. BFD wants to see the
1383 size in the value field, and doesn't care (at the
1384 moment) about the alignment. */
1385 sym
->symbol
.value
= isym
->st_size
;
1387 else if (elf_use_dt_symtab_p (abfd
))
1390 sec
= _bfd_elf_get_section_from_dynamic_symbol (abfd
,
1394 sym
->symbol
.section
= sec
;
1399 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1400 if (sym
->symbol
.section
== NULL
)
1402 /* This symbol is in a section for which we did not
1403 create a BFD section. Just use bfd_abs_section,
1404 although it is wrong. FIXME. Note - there is
1405 code in elf.c:swap_out_syms that calls
1406 symbol_section_index() in the elf backend for
1408 sym
->symbol
.section
= bfd_abs_section_ptr
;
1412 /* If this is a relocatable file, then the symbol value is
1413 already section relative. */
1414 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1415 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1417 switch (ELF_ST_BIND (isym
->st_info
))
1420 sym
->symbol
.flags
|= BSF_LOCAL
;
1423 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1424 sym
->symbol
.flags
|= BSF_GLOBAL
;
1427 sym
->symbol
.flags
|= BSF_WEAK
;
1429 case STB_GNU_UNIQUE
:
1430 sym
->symbol
.flags
|= BSF_GNU_UNIQUE
;
1434 switch (ELF_ST_TYPE (isym
->st_info
))
1437 /* Mark the input section symbol as used since it may be
1438 used for relocation and section group.
1439 NB: BSF_SECTION_SYM_USED is ignored by linker and may
1440 be cleared by objcopy for non-relocatable inputs. */
1441 sym
->symbol
.flags
|= (BSF_SECTION_SYM
1443 | BSF_SECTION_SYM_USED
);
1446 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1449 sym
->symbol
.flags
|= BSF_FUNCTION
;
1452 /* FIXME: Do we have to put the size field into the value field
1453 as we do with symbols in SHN_COMMON sections (see above) ? */
1454 sym
->symbol
.flags
|= BSF_ELF_COMMON
;
1457 sym
->symbol
.flags
|= BSF_OBJECT
;
1460 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1463 sym
->symbol
.flags
|= BSF_RELC
;
1466 sym
->symbol
.flags
|= BSF_SRELC
;
1469 sym
->symbol
.flags
|= BSF_GNU_INDIRECT_FUNCTION
;
1474 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1476 if (elf_tdata (abfd
)->dt_versym
)
1477 sym
->version
= bfd_get_16 (abfd
,
1478 elf_tdata (abfd
)->dt_versym
+ 2 * i
);
1479 else if (xver
!= NULL
)
1481 Elf_Internal_Versym iversym
;
1483 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1484 sym
->version
= iversym
.vs_vers
;
1488 /* Do some backend-specific processing on this symbol. */
1489 if (ebd
->elf_backend_symbol_processing
)
1490 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1494 /* Do some backend-specific processing on this symbol table. */
1495 if (ebd
->elf_backend_symbol_table_processing
)
1496 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1498 /* We rely on the zalloc to clear out the final symbol entry. */
1500 symcount
= sym
- symbase
;
1502 /* Fill in the user's symbol pointer vector if needed. */
1510 *symptrs
++ = &sym
->symbol
;
1513 *symptrs
= 0; /* Final null pointer */
1517 if (hdr
->contents
!= (unsigned char *) isymbuf
1518 && !elf_use_dt_symtab_p (abfd
))
1524 if (hdr
->contents
!= (unsigned char *) isymbuf
1525 && !elf_use_dt_symtab_p (abfd
))
1530 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1534 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1536 Elf_Internal_Shdr
*rel_hdr
,
1537 bfd_size_type reloc_count
,
1542 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1543 void *allocated
= NULL
;
1544 bfd_byte
*native_relocs
;
1548 unsigned int symcount
;
1550 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1552 allocated
= _bfd_malloc_and_read (abfd
, rel_hdr
->sh_size
, rel_hdr
->sh_size
);
1553 if (allocated
== NULL
)
1556 native_relocs
= (bfd_byte
*) allocated
;
1558 entsize
= rel_hdr
->sh_entsize
;
1559 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1560 || entsize
== sizeof (Elf_External_Rela
));
1563 symcount
= bfd_get_dynamic_symcount (abfd
);
1565 symcount
= bfd_get_symcount (abfd
);
1567 for (i
= 0, relent
= relents
;
1569 i
++, relent
++, native_relocs
+= entsize
)
1572 Elf_Internal_Rela rela
;
1574 if (entsize
== sizeof (Elf_External_Rela
))
1575 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1577 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1579 /* The address of an ELF reloc is section relative for an object
1580 file, and absolute for an executable file or shared library.
1581 The address of a normal BFD reloc is always section relative,
1582 and the address of a dynamic reloc is absolute.. */
1583 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1584 relent
->address
= rela
.r_offset
;
1586 relent
->address
= rela
.r_offset
- asect
->vma
;
1588 if (ELF_R_SYM (rela
.r_info
) == STN_UNDEF
)
1589 /* FIXME: This and the error case below mean that we have a
1590 symbol on relocs that is not elf_symbol_type. */
1591 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1592 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1595 /* xgettext:c-format */
1596 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
1597 abfd
, asect
, i
, (long) ELF_R_SYM (rela
.r_info
));
1598 bfd_set_error (bfd_error_bad_value
);
1599 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1605 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1607 relent
->sym_ptr_ptr
= ps
;
1610 relent
->addend
= rela
.r_addend
;
1612 if ((entsize
== sizeof (Elf_External_Rela
)
1613 && ebd
->elf_info_to_howto
!= NULL
)
1614 || ebd
->elf_info_to_howto_rel
== NULL
)
1615 res
= ebd
->elf_info_to_howto (abfd
, relent
, &rela
);
1617 res
= ebd
->elf_info_to_howto_rel (abfd
, relent
, &rela
);
1619 if (! res
|| relent
->howto
== NULL
)
1631 /* Read in and swap the external relocs. */
1634 elf_slurp_reloc_table (bfd
*abfd
,
1639 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
1640 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1641 Elf_Internal_Shdr
*rel_hdr
;
1642 Elf_Internal_Shdr
*rel_hdr2
;
1643 bfd_size_type reloc_count
;
1644 bfd_size_type reloc_count2
;
1648 if (asect
->relocation
!= NULL
)
1653 if ((asect
->flags
& SEC_RELOC
) == 0
1654 || asect
->reloc_count
== 0)
1657 rel_hdr
= d
->rel
.hdr
;
1658 reloc_count
= rel_hdr
? NUM_SHDR_ENTRIES (rel_hdr
) : 0;
1659 rel_hdr2
= d
->rela
.hdr
;
1660 reloc_count2
= rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0;
1662 /* PR 17512: file: 0b4f81b7. */
1663 if (asect
->reloc_count
!= reloc_count
+ reloc_count2
)
1665 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
1666 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1671 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1672 case because relocations against this section may use the
1673 dynamic symbol table, and in that case bfd_section_from_shdr
1674 in elf.c does not update the RELOC_COUNT. */
1675 if (asect
->size
== 0)
1678 rel_hdr
= &d
->this_hdr
;
1679 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1684 if (_bfd_mul_overflow (reloc_count
+ reloc_count2
, sizeof (arelent
), &amt
))
1686 bfd_set_error (bfd_error_file_too_big
);
1689 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1690 if (relents
== NULL
)
1694 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1695 rel_hdr
, reloc_count
,
1701 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1702 rel_hdr2
, reloc_count2
,
1703 relents
+ reloc_count
,
1707 if (!bed
->slurp_secondary_relocs (abfd
, asect
, symbols
, dynamic
))
1710 asect
->relocation
= relents
;
1716 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1718 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1719 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1722 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1723 (long) hdr
->sh_name
,
1724 (long) hdr
->sh_type
,
1725 (long) hdr
->sh_flags
);
1727 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1728 (long) hdr
->sh_addr
,
1729 (long) hdr
->sh_offset
,
1730 (long) hdr
->sh_size
);
1732 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1733 (long) hdr
->sh_link
,
1734 (long) hdr
->sh_info
,
1735 (long) hdr
->sh_addralign
);
1736 fprintf (stderr
, "sh_entsize = %ld\n",
1737 (long) hdr
->sh_entsize
);
1744 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1746 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1747 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1748 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1749 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1750 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1751 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1752 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1756 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1757 reconstruct an ELF file by reading the segments out of remote
1758 memory based on the ELF file header at EHDR_VMA and the ELF program
1759 headers it points to. If non-zero, SIZE is the known extent of the
1760 object. If not null, *LOADBASEP is filled in with the difference
1761 between the VMAs from which the segments were read, and the VMAs
1762 the file headers (and hence BFD's idea of each section's VMA) put
1765 The function TARGET_READ_MEMORY is called to copy LEN bytes from
1766 the remote memory at target address VMA into the local buffer at
1767 MYADDR; it should return zero on success or an `errno' code on
1768 failure. TEMPL must be a BFD for a target with the word size and
1769 byte order found in the remote memory. */
1772 NAME(_bfd_elf
,bfd_from_remote_memory
)
1774 bfd_vma ehdr_vma
/* Bytes. */,
1775 bfd_size_type size
/* Octets. */,
1776 bfd_vma
*loadbasep
/* Bytes. */,
1777 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
1778 /* (Bytes , , octets ). */
1780 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1781 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1782 Elf_External_Phdr
*x_phdrs
;
1783 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
, *first_phdr
;
1785 struct bfd_in_memory
*bim
;
1789 bfd_vma high_offset
;
1791 bfd_vma loadbase
; /* Bytes. */
1793 unsigned int opb
= bfd_octets_per_byte (templ
, NULL
);
1795 /* Read in the ELF header in external format. */
1796 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1799 bfd_set_error (bfd_error_system_call
);
1804 /* Now check to see if we have a valid ELF file, and one that BFD can
1805 make use of. The magic number must match, the address size ('class')
1806 and byte-swapping must match our XVEC entry. */
1808 if (! elf_file_p (&x_ehdr
)
1809 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1810 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1812 bfd_set_error (bfd_error_wrong_format
);
1816 /* Check that file's byte order matches xvec's */
1817 switch (x_ehdr
.e_ident
[EI_DATA
])
1819 case ELFDATA2MSB
: /* Big-endian */
1820 if (! bfd_header_big_endian (templ
))
1822 bfd_set_error (bfd_error_wrong_format
);
1826 case ELFDATA2LSB
: /* Little-endian */
1827 if (! bfd_header_little_endian (templ
))
1829 bfd_set_error (bfd_error_wrong_format
);
1833 case ELFDATANONE
: /* No data encoding specified */
1834 default: /* Unknown data encoding specified */
1835 bfd_set_error (bfd_error_wrong_format
);
1839 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1841 /* The file header tells where to find the program headers.
1842 These are what we use to actually choose what to read. */
1844 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1846 bfd_set_error (bfd_error_wrong_format
);
1850 if (_bfd_mul_overflow (i_ehdr
.e_phnum
,
1851 sizeof (*x_phdrs
) + sizeof (*i_phdrs
), &amt
))
1853 bfd_set_error (bfd_error_file_too_big
);
1856 x_phdrs
= (Elf_External_Phdr
*) bfd_malloc (amt
);
1857 if (x_phdrs
== NULL
)
1859 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1860 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1864 bfd_set_error (bfd_error_system_call
);
1868 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1874 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1876 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1877 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1879 bfd_vma segment_end
= i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
;
1881 if (segment_end
> high_offset
)
1883 high_offset
= segment_end
;
1884 last_phdr
= &i_phdrs
[i
];
1887 /* If this program header covers offset zero, where the file
1888 header sits, then we can figure out the loadbase. */
1889 if (first_phdr
== NULL
)
1891 bfd_vma p_offset
= i_phdrs
[i
].p_offset
; /* Octets. */
1892 bfd_vma p_vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1894 if (i_phdrs
[i
].p_align
> 1)
1896 p_offset
&= -(i_phdrs
[i
].p_align
* opb
);
1897 p_vaddr
&= -(i_phdrs
[i
].p_align
* opb
);
1901 loadbase
= ehdr_vma
- p_vaddr
/ opb
;
1902 first_phdr
= &i_phdrs
[i
];
1907 if (high_offset
== 0)
1909 /* There were no PT_LOAD segments, so we don't have anything to read. */
1911 bfd_set_error (bfd_error_wrong_format
);
1916 if (i_ehdr
.e_shoff
!= 0 && i_ehdr
.e_shnum
!= 0 && i_ehdr
.e_shentsize
!= 0)
1918 shdr_end
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1920 if (last_phdr
->p_filesz
!= last_phdr
->p_memsz
)
1922 /* If the last PT_LOAD header has a bss area then ld.so will
1923 have cleared anything past p_filesz, zapping the section
1926 else if (size
>= shdr_end
)
1930 bfd_vma page_size
= get_elf_backend_data (templ
)->minpagesize
;
1931 bfd_vma segment_end
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1933 /* Assume we loaded full pages, allowing us to sometimes see
1935 if (page_size
> 1 && shdr_end
> segment_end
)
1937 bfd_vma page_end
= (segment_end
+ page_size
- 1) & -page_size
;
1939 if (page_end
>= shdr_end
)
1940 /* Whee, section headers covered. */
1941 high_offset
= shdr_end
;
1946 /* Now we know the size of the whole image we want read in. */
1947 contents
= (bfd_byte
*) bfd_zmalloc (high_offset
);
1948 if (contents
== NULL
)
1954 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1955 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1957 bfd_vma start
= i_phdrs
[i
].p_offset
; /* Octets. */
1958 bfd_vma end
= start
+ i_phdrs
[i
].p_filesz
; /* Octets. */
1959 bfd_vma vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1961 /* Extend the beginning of the first pt_load to cover file
1962 header and program headers, if we proved earlier that its
1963 aligned offset is 0. */
1964 if (first_phdr
== &i_phdrs
[i
])
1969 /* Extend the end of the last pt_load to cover section headers. */
1970 if (last_phdr
== &i_phdrs
[i
])
1972 err
= target_read_memory (loadbase
+ vaddr
/ opb
,
1973 contents
+ start
, end
- start
);
1978 bfd_set_error (bfd_error_system_call
);
1985 /* If the segments visible in memory didn't include the section headers,
1986 then clear them from the file header. */
1987 if (high_offset
< shdr_end
)
1989 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1990 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1991 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1994 /* This will normally have been in the first PT_LOAD segment. But it
1995 conceivably could be missing, and we might have just changed it. */
1996 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1998 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1999 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
2005 nbfd
= _bfd_new_bfd ();
2007 || !bfd_set_filename (nbfd
, "<in-memory>"))
2013 nbfd
->xvec
= templ
->xvec
;
2014 bim
->size
= high_offset
;
2015 bim
->buffer
= contents
;
2016 nbfd
->iostream
= bim
;
2017 nbfd
->flags
= BFD_IN_MEMORY
;
2018 nbfd
->iovec
= &_bfd_memory_iovec
;
2020 nbfd
->direction
= read_direction
;
2021 nbfd
->mtime
= time (NULL
);
2022 nbfd
->mtime_set
= true;
2025 *loadbasep
= loadbase
;
2029 /* Function for ELF_R_INFO. */
2032 NAME(elf
,r_info
) (bfd_vma sym
, bfd_vma type
)
2034 return ELF_R_INFO (sym
, type
);
2037 /* Function for ELF_R_SYM. */
2040 NAME(elf
,r_sym
) (bfd_vma r_info
)
2042 return ELF_R_SYM (r_info
);
2045 #include "elfcore.h"
2047 /* Size-dependent data and functions. */
2048 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
2049 sizeof (Elf_External_Ehdr
),
2050 sizeof (Elf_External_Phdr
),
2051 sizeof (Elf_External_Shdr
),
2052 sizeof (Elf_External_Rel
),
2053 sizeof (Elf_External_Rela
),
2054 sizeof (Elf_External_Sym
),
2055 sizeof (Elf_External_Dyn
),
2056 sizeof (Elf_External_Note
),
2059 ARCH_SIZE
, LOG_FILE_ALIGN
,
2060 ELFCLASS
, EV_CURRENT
,
2061 elf_write_out_phdrs
,
2062 elf_write_shdrs_and_ehdr
,
2063 elf_checksum_contents
,
2066 elf_swap_symbol_out
,
2067 elf_slurp_reloc_table
,
2068 elf_slurp_symbol_table
,