1 /* ELF executable support for BFD.
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 3 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
31 MA 02110-1301, USA. */
34 /* Problems and other issues to resolve.
36 (1) BFD expects there to be some fixed number of "sections" in
37 the object file. I.E. there is a "section_count" variable in the
38 bfd structure which contains the number of sections. However, ELF
39 supports multiple "views" of a file. In particular, with current
40 implementations, executable files typically have two tables, a
41 program header table and a section header table, both of which
42 partition the executable.
44 In ELF-speak, the "linking view" of the file uses the section header
45 table to access "sections" within the file, and the "execution view"
46 uses the program header table to access "segments" within the file.
47 "Segments" typically may contain all the data from one or more
50 Note that the section header table is optional in ELF executables,
51 but it is this information that is most useful to gdb. If the
52 section header table is missing, then gdb should probably try
53 to make do with the program header table. (FIXME)
55 (2) The code in this file is compiled twice, once in 32-bit mode and
56 once in 64-bit mode. More of it should be made size-independent
59 (3) ELF section symbols are handled rather sloppily now. This should
60 be cleaned up, and ELF section symbols reconciled with BFD section
63 (4) We need a published spec for 64-bit ELF. We've got some stuff here
64 that we're using for SPARC V9 64-bit chips, but don't assume that
70 #include "libiberty.h"
74 #include "libiberty.h"
76 /* Renaming structures, typedefs, macros and functions to be size-specific. */
77 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
78 #define Elf_External_Sym NAME(Elf,External_Sym)
79 #define Elf_External_Shdr NAME(Elf,External_Shdr)
80 #define Elf_External_Phdr NAME(Elf,External_Phdr)
81 #define Elf_External_Rel NAME(Elf,External_Rel)
82 #define Elf_External_Rela NAME(Elf,External_Rela)
83 #define Elf_External_Dyn NAME(Elf,External_Dyn)
85 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
86 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
87 #define elf_core_file_matches_executable_p \
88 NAME(bfd_elf,core_file_matches_executable_p)
89 #define elf_core_file_pid NAME(bfd_elf,core_file_pid)
90 #define elf_object_p NAME(bfd_elf,object_p)
91 #define elf_core_file_p NAME(bfd_elf,core_file_p)
92 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
93 #define elf_get_dynamic_symtab_upper_bound \
94 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
95 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
96 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
97 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
98 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
99 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
100 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
101 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
102 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
103 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
104 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
105 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
106 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
107 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
108 #define elf_canonicalize_symtab NAME(bfd_elf,canonicalize_symtab)
109 #define elf_canonicalize_dynamic_symtab \
110 NAME(bfd_elf,canonicalize_dynamic_symtab)
111 #define elf_get_synthetic_symtab \
112 NAME(bfd_elf,get_synthetic_symtab)
113 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
114 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
115 #define elf_get_lineno NAME(bfd_elf,get_lineno)
116 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
117 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
118 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
119 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
120 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
121 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
122 #define elf_find_section NAME(bfd_elf,find_section)
123 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
124 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
125 #define elf_checksum_contents NAME(bfd_elf,checksum_contents)
126 #define elf_write_relocs NAME(bfd_elf,write_relocs)
127 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
130 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
131 #define ELF_R_SYM(X) ELF64_R_SYM(X)
132 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
133 #define ELFCLASS ELFCLASS64
135 #define LOG_FILE_ALIGN 3
138 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
139 #define ELF_R_SYM(X) ELF32_R_SYM(X)
140 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
141 #define ELFCLASS ELFCLASS32
143 #define LOG_FILE_ALIGN 2
147 static void elf_debug_section (int, Elf_Internal_Shdr
*);
150 static void elf_debug_file (Elf_Internal_Ehdr
*);
153 /* Structure swapping routines */
155 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
156 can be handled by explicitly specifying 32 bits or "the long type". */
158 #define H_PUT_WORD H_PUT_64
159 #define H_PUT_SIGNED_WORD H_PUT_S64
160 #define H_GET_WORD H_GET_64
161 #define H_GET_SIGNED_WORD H_GET_S64
164 #define H_PUT_WORD H_PUT_32
165 #define H_PUT_SIGNED_WORD H_PUT_S32
166 #define H_GET_WORD H_GET_32
167 #define H_GET_SIGNED_WORD H_GET_S32
170 /* Translate an ELF symbol in external format into an ELF symbol in internal
174 elf_swap_symbol_in (bfd
*abfd
,
177 Elf_Internal_Sym
*dst
)
179 const Elf_External_Sym
*src
= (const Elf_External_Sym
*) psrc
;
180 const Elf_External_Sym_Shndx
*shndx
= (const Elf_External_Sym_Shndx
*) pshn
;
181 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
183 dst
->st_name
= H_GET_32 (abfd
, src
->st_name
);
185 dst
->st_value
= H_GET_SIGNED_WORD (abfd
, src
->st_value
);
187 dst
->st_value
= H_GET_WORD (abfd
, src
->st_value
);
188 dst
->st_size
= H_GET_WORD (abfd
, src
->st_size
);
189 dst
->st_info
= H_GET_8 (abfd
, src
->st_info
);
190 dst
->st_other
= H_GET_8 (abfd
, src
->st_other
);
191 dst
->st_shndx
= H_GET_16 (abfd
, src
->st_shndx
);
192 if (dst
->st_shndx
== (SHN_XINDEX
& 0xffff))
196 dst
->st_shndx
= H_GET_32 (abfd
, shndx
->est_shndx
);
198 else if (dst
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
199 dst
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
200 dst
->st_target_internal
= 0;
204 /* Translate an ELF symbol in internal format into an ELF symbol in external
208 elf_swap_symbol_out (bfd
*abfd
,
209 const Elf_Internal_Sym
*src
,
214 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
215 H_PUT_32 (abfd
, src
->st_name
, dst
->st_name
);
216 H_PUT_WORD (abfd
, src
->st_value
, dst
->st_value
);
217 H_PUT_WORD (abfd
, src
->st_size
, dst
->st_size
);
218 H_PUT_8 (abfd
, src
->st_info
, dst
->st_info
);
219 H_PUT_8 (abfd
, src
->st_other
, dst
->st_other
);
221 if (tmp
>= (SHN_LORESERVE
& 0xffff) && tmp
< SHN_LORESERVE
)
225 H_PUT_32 (abfd
, tmp
, shndx
);
226 tmp
= SHN_XINDEX
& 0xffff;
228 H_PUT_16 (abfd
, tmp
, dst
->st_shndx
);
231 /* Translate an ELF file header in external format into an ELF file header in
235 elf_swap_ehdr_in (bfd
*abfd
,
236 const Elf_External_Ehdr
*src
,
237 Elf_Internal_Ehdr
*dst
)
239 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
240 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
241 dst
->e_type
= H_GET_16 (abfd
, src
->e_type
);
242 dst
->e_machine
= H_GET_16 (abfd
, src
->e_machine
);
243 dst
->e_version
= H_GET_32 (abfd
, src
->e_version
);
245 dst
->e_entry
= H_GET_SIGNED_WORD (abfd
, src
->e_entry
);
247 dst
->e_entry
= H_GET_WORD (abfd
, src
->e_entry
);
248 dst
->e_phoff
= H_GET_WORD (abfd
, src
->e_phoff
);
249 dst
->e_shoff
= H_GET_WORD (abfd
, src
->e_shoff
);
250 dst
->e_flags
= H_GET_32 (abfd
, src
->e_flags
);
251 dst
->e_ehsize
= H_GET_16 (abfd
, src
->e_ehsize
);
252 dst
->e_phentsize
= H_GET_16 (abfd
, src
->e_phentsize
);
253 dst
->e_phnum
= H_GET_16 (abfd
, src
->e_phnum
);
254 dst
->e_shentsize
= H_GET_16 (abfd
, src
->e_shentsize
);
255 dst
->e_shnum
= H_GET_16 (abfd
, src
->e_shnum
);
256 dst
->e_shstrndx
= H_GET_16 (abfd
, src
->e_shstrndx
);
259 /* Translate an ELF file header in internal format into an ELF file header in
263 elf_swap_ehdr_out (bfd
*abfd
,
264 const Elf_Internal_Ehdr
*src
,
265 Elf_External_Ehdr
*dst
)
268 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
269 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
270 /* note that all elements of dst are *arrays of unsigned char* already... */
271 H_PUT_16 (abfd
, src
->e_type
, dst
->e_type
);
272 H_PUT_16 (abfd
, src
->e_machine
, dst
->e_machine
);
273 H_PUT_32 (abfd
, src
->e_version
, dst
->e_version
);
275 H_PUT_SIGNED_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
277 H_PUT_WORD (abfd
, src
->e_entry
, dst
->e_entry
);
278 H_PUT_WORD (abfd
, src
->e_phoff
, dst
->e_phoff
);
279 H_PUT_WORD (abfd
, src
->e_shoff
, dst
->e_shoff
);
280 H_PUT_32 (abfd
, src
->e_flags
, dst
->e_flags
);
281 H_PUT_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
282 H_PUT_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
286 H_PUT_16 (abfd
, tmp
, dst
->e_phnum
);
287 H_PUT_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
289 if (tmp
>= (SHN_LORESERVE
& 0xffff))
291 H_PUT_16 (abfd
, tmp
, dst
->e_shnum
);
292 tmp
= src
->e_shstrndx
;
293 if (tmp
>= (SHN_LORESERVE
& 0xffff))
294 tmp
= SHN_XINDEX
& 0xffff;
295 H_PUT_16 (abfd
, tmp
, dst
->e_shstrndx
);
298 /* Translate an ELF section header table entry in external format into an
299 ELF section header table entry in internal format. */
302 elf_swap_shdr_in (bfd
*abfd
,
303 const Elf_External_Shdr
*src
,
304 Elf_Internal_Shdr
*dst
)
306 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
308 dst
->sh_name
= H_GET_32 (abfd
, src
->sh_name
);
309 dst
->sh_type
= H_GET_32 (abfd
, src
->sh_type
);
310 dst
->sh_flags
= H_GET_WORD (abfd
, src
->sh_flags
);
312 dst
->sh_addr
= H_GET_SIGNED_WORD (abfd
, src
->sh_addr
);
314 dst
->sh_addr
= H_GET_WORD (abfd
, src
->sh_addr
);
315 dst
->sh_offset
= H_GET_WORD (abfd
, src
->sh_offset
);
316 dst
->sh_size
= H_GET_WORD (abfd
, src
->sh_size
);
317 /* PR 23657. Check for invalid section size, in sections with contents.
318 Note - we do not set an error value here because the contents
319 of this particular section might not be needed by the consumer. */
320 if (dst
->sh_type
!= SHT_NOBITS
)
322 ufile_ptr filesize
= bfd_get_file_size (abfd
);
324 if (filesize
!= 0 && dst
->sh_size
> filesize
)
326 (_("warning: %pB has a corrupt section with a size (%"
327 BFD_VMA_FMT
"x) larger than the file size"),
330 dst
->sh_link
= H_GET_32 (abfd
, src
->sh_link
);
331 dst
->sh_info
= H_GET_32 (abfd
, src
->sh_info
);
332 dst
->sh_addralign
= H_GET_WORD (abfd
, src
->sh_addralign
);
333 dst
->sh_entsize
= H_GET_WORD (abfd
, src
->sh_entsize
);
334 dst
->bfd_section
= NULL
;
335 dst
->contents
= NULL
;
338 /* Translate an ELF section header table entry in internal format into an
339 ELF section header table entry in external format. */
342 elf_swap_shdr_out (bfd
*abfd
,
343 const Elf_Internal_Shdr
*src
,
344 Elf_External_Shdr
*dst
)
346 /* note that all elements of dst are *arrays of unsigned char* already... */
347 H_PUT_32 (abfd
, src
->sh_name
, dst
->sh_name
);
348 H_PUT_32 (abfd
, src
->sh_type
, dst
->sh_type
);
349 H_PUT_WORD (abfd
, src
->sh_flags
, dst
->sh_flags
);
350 H_PUT_WORD (abfd
, src
->sh_addr
, dst
->sh_addr
);
351 H_PUT_WORD (abfd
, src
->sh_offset
, dst
->sh_offset
);
352 H_PUT_WORD (abfd
, src
->sh_size
, dst
->sh_size
);
353 H_PUT_32 (abfd
, src
->sh_link
, dst
->sh_link
);
354 H_PUT_32 (abfd
, src
->sh_info
, dst
->sh_info
);
355 H_PUT_WORD (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
356 H_PUT_WORD (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
359 /* Translate an ELF program header table entry in external format into an
360 ELF program header table entry in internal format. */
363 elf_swap_phdr_in (bfd
*abfd
,
364 const Elf_External_Phdr
*src
,
365 Elf_Internal_Phdr
*dst
)
367 int signed_vma
= get_elf_backend_data (abfd
)->sign_extend_vma
;
369 dst
->p_type
= H_GET_32 (abfd
, src
->p_type
);
370 dst
->p_flags
= H_GET_32 (abfd
, src
->p_flags
);
371 dst
->p_offset
= H_GET_WORD (abfd
, src
->p_offset
);
374 dst
->p_vaddr
= H_GET_SIGNED_WORD (abfd
, src
->p_vaddr
);
375 dst
->p_paddr
= H_GET_SIGNED_WORD (abfd
, src
->p_paddr
);
379 dst
->p_vaddr
= H_GET_WORD (abfd
, src
->p_vaddr
);
380 dst
->p_paddr
= H_GET_WORD (abfd
, src
->p_paddr
);
382 dst
->p_filesz
= H_GET_WORD (abfd
, src
->p_filesz
);
383 dst
->p_memsz
= H_GET_WORD (abfd
, src
->p_memsz
);
384 dst
->p_align
= H_GET_WORD (abfd
, src
->p_align
);
388 elf_swap_phdr_out (bfd
*abfd
,
389 const Elf_Internal_Phdr
*src
,
390 Elf_External_Phdr
*dst
)
392 const struct elf_backend_data
*bed
;
395 bed
= get_elf_backend_data (abfd
);
396 p_paddr
= bed
->want_p_paddr_set_to_zero
? 0 : src
->p_paddr
;
398 /* note that all elements of dst are *arrays of unsigned char* already... */
399 H_PUT_32 (abfd
, src
->p_type
, dst
->p_type
);
400 H_PUT_WORD (abfd
, src
->p_offset
, dst
->p_offset
);
401 H_PUT_WORD (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
402 H_PUT_WORD (abfd
, p_paddr
, dst
->p_paddr
);
403 H_PUT_WORD (abfd
, src
->p_filesz
, dst
->p_filesz
);
404 H_PUT_WORD (abfd
, src
->p_memsz
, dst
->p_memsz
);
405 H_PUT_32 (abfd
, src
->p_flags
, dst
->p_flags
);
406 H_PUT_WORD (abfd
, src
->p_align
, dst
->p_align
);
409 /* Translate an ELF reloc from external format to internal format. */
411 elf_swap_reloc_in (bfd
*abfd
,
413 Elf_Internal_Rela
*dst
)
415 const Elf_External_Rel
*src
= (const Elf_External_Rel
*) s
;
416 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
417 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
422 elf_swap_reloca_in (bfd
*abfd
,
424 Elf_Internal_Rela
*dst
)
426 const Elf_External_Rela
*src
= (const Elf_External_Rela
*) s
;
427 dst
->r_offset
= H_GET_WORD (abfd
, src
->r_offset
);
428 dst
->r_info
= H_GET_WORD (abfd
, src
->r_info
);
429 dst
->r_addend
= H_GET_SIGNED_WORD (abfd
, src
->r_addend
);
432 /* Translate an ELF reloc from internal format to external format. */
434 elf_swap_reloc_out (bfd
*abfd
,
435 const Elf_Internal_Rela
*src
,
438 Elf_External_Rel
*dst
= (Elf_External_Rel
*) d
;
439 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
440 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
444 elf_swap_reloca_out (bfd
*abfd
,
445 const Elf_Internal_Rela
*src
,
448 Elf_External_Rela
*dst
= (Elf_External_Rela
*) d
;
449 H_PUT_WORD (abfd
, src
->r_offset
, dst
->r_offset
);
450 H_PUT_WORD (abfd
, src
->r_info
, dst
->r_info
);
451 H_PUT_SIGNED_WORD (abfd
, src
->r_addend
, dst
->r_addend
);
455 elf_swap_dyn_in (bfd
*abfd
,
457 Elf_Internal_Dyn
*dst
)
459 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
461 dst
->d_tag
= H_GET_WORD (abfd
, src
->d_tag
);
462 dst
->d_un
.d_val
= H_GET_WORD (abfd
, src
->d_un
.d_val
);
466 elf_swap_dyn_out (bfd
*abfd
,
467 const Elf_Internal_Dyn
*src
,
470 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
472 H_PUT_WORD (abfd
, src
->d_tag
, dst
->d_tag
);
473 H_PUT_WORD (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
476 /* ELF .o/exec file reading */
478 /* Begin processing a given object.
480 First we validate the file by reading in the ELF header and checking
483 static inline bfd_boolean
484 elf_file_p (Elf_External_Ehdr
*x_ehdrp
)
486 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
487 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
488 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
489 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
492 /* Check to see if the file associated with ABFD matches the target vector
495 Note that we may be called several times with the same ABFD, but different
496 target vectors, most of which will not match. We have to avoid leaving
497 any side effects in ABFD, or any data it points to (like tdata), if the
498 file does not match the target vector. */
501 elf_object_p (bfd
*abfd
)
503 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
504 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
505 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
506 Elf_Internal_Shdr i_shdr
;
507 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
508 unsigned int shindex
;
509 const struct elf_backend_data
*ebd
;
511 const bfd_target
*target
;
513 /* Read in the ELF header in external format. */
515 if (bfd_bread (&x_ehdr
, sizeof (x_ehdr
), abfd
) != sizeof (x_ehdr
))
517 if (bfd_get_error () != bfd_error_system_call
)
518 goto got_wrong_format_error
;
523 /* Now check to see if we have a valid ELF file, and one that BFD can
524 make use of. The magic number must match, the address size ('class')
525 and byte-swapping must match our XVEC entry, and it must have a
526 section header table (FIXME: See comments re sections at top of this
529 if (! elf_file_p (&x_ehdr
)
530 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
531 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
532 goto got_wrong_format_error
;
534 /* Check that file's byte order matches xvec's */
535 switch (x_ehdr
.e_ident
[EI_DATA
])
537 case ELFDATA2MSB
: /* Big-endian */
538 if (! bfd_header_big_endian (abfd
))
539 goto got_wrong_format_error
;
541 case ELFDATA2LSB
: /* Little-endian */
542 if (! bfd_header_little_endian (abfd
))
543 goto got_wrong_format_error
;
545 case ELFDATANONE
: /* No data encoding specified */
546 default: /* Unknown data encoding specified */
547 goto got_wrong_format_error
;
552 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
553 the tdata pointer in the bfd. */
555 if (! (*target
->_bfd_set_format
[bfd_object
]) (abfd
))
558 /* Now that we know the byte order, swap in the rest of the header */
559 i_ehdrp
= elf_elfheader (abfd
);
560 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
562 elf_debug_file (i_ehdrp
);
565 /* Reject ET_CORE (header indicates core file, not object file) */
566 if (i_ehdrp
->e_type
== ET_CORE
)
567 goto got_wrong_format_error
;
569 /* If this is a relocatable file and there is no section header
570 table, then we're hosed. */
571 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_type
== ET_REL
)
572 goto got_wrong_format_error
;
574 /* As a simple sanity check, verify that what BFD thinks is the
575 size of each section header table entry actually matches the size
576 recorded in the file, but only if there are any sections. */
577 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
) && i_ehdrp
->e_shnum
!= 0)
578 goto got_wrong_format_error
;
580 /* Further sanity check. */
581 if (i_ehdrp
->e_shoff
== 0 && i_ehdrp
->e_shnum
!= 0)
582 goto got_wrong_format_error
;
584 ebd
= get_elf_backend_data (abfd
);
585 if (ebd
->s
->arch_size
!= ARCH_SIZE
)
586 goto got_wrong_format_error
;
588 /* Check that the ELF e_machine field matches what this particular
589 BFD format expects. */
590 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
591 && (ebd
->elf_machine_alt1
== 0
592 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
593 && (ebd
->elf_machine_alt2
== 0
594 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
)
595 && ebd
->elf_machine_code
!= EM_NONE
)
596 goto got_wrong_format_error
;
598 if (i_ehdrp
->e_type
== ET_EXEC
)
599 abfd
->flags
|= EXEC_P
;
600 else if (i_ehdrp
->e_type
== ET_DYN
)
601 abfd
->flags
|= DYNAMIC
;
603 if (i_ehdrp
->e_phnum
> 0)
604 abfd
->flags
|= D_PAGED
;
606 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
608 /* It's OK if this fails for the generic target. */
609 if (ebd
->elf_machine_code
!= EM_NONE
)
613 if (ebd
->elf_machine_code
!= EM_NONE
614 && i_ehdrp
->e_ident
[EI_OSABI
] != ebd
->elf_osabi
615 && ebd
->elf_osabi
!= ELFOSABI_NONE
)
616 goto got_wrong_format_error
;
618 if (i_ehdrp
->e_shoff
!= 0)
620 file_ptr where
= (file_ptr
) i_ehdrp
->e_shoff
;
622 /* Seek to the section header table in the file. */
623 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
626 /* Read the first section header at index 0, and convert to internal
628 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
630 elf_swap_shdr_in (abfd
, &x_shdr
, &i_shdr
);
632 /* If the section count is zero, the actual count is in the first
634 if (i_ehdrp
->e_shnum
== SHN_UNDEF
)
636 i_ehdrp
->e_shnum
= i_shdr
.sh_size
;
637 if (i_ehdrp
->e_shnum
>= SHN_LORESERVE
638 || i_ehdrp
->e_shnum
!= i_shdr
.sh_size
639 || i_ehdrp
->e_shnum
== 0)
640 goto got_wrong_format_error
;
643 /* And similarly for the string table index. */
644 if (i_ehdrp
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
646 i_ehdrp
->e_shstrndx
= i_shdr
.sh_link
;
647 if (i_ehdrp
->e_shstrndx
!= i_shdr
.sh_link
)
648 goto got_wrong_format_error
;
651 /* And program headers. */
652 if (i_ehdrp
->e_phnum
== PN_XNUM
&& i_shdr
.sh_info
!= 0)
654 i_ehdrp
->e_phnum
= i_shdr
.sh_info
;
655 if (i_ehdrp
->e_phnum
!= i_shdr
.sh_info
)
656 goto got_wrong_format_error
;
659 /* Sanity check that we can read all of the section headers.
660 It ought to be good enough to just read the last one. */
661 if (i_ehdrp
->e_shnum
!= 1)
663 /* Check that we don't have a totally silly number of sections. */
664 if (i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (x_shdr
)
665 || i_ehdrp
->e_shnum
> (unsigned int) -1 / sizeof (i_shdr
))
666 goto got_wrong_format_error
;
668 where
+= (i_ehdrp
->e_shnum
- 1) * sizeof (x_shdr
);
669 if ((bfd_size_type
) where
<= i_ehdrp
->e_shoff
)
670 goto got_wrong_format_error
;
672 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
674 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
677 /* Back to where we were. */
678 where
= i_ehdrp
->e_shoff
+ sizeof (x_shdr
);
679 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0)
684 /* Allocate space for a copy of the section header table in
686 if (i_ehdrp
->e_shnum
!= 0)
688 Elf_Internal_Shdr
*shdrp
;
689 unsigned int num_sec
;
692 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*i_shdrp
), &amt
))
693 goto got_wrong_format_error
;
694 i_shdrp
= (Elf_Internal_Shdr
*) bfd_alloc (abfd
, amt
);
697 num_sec
= i_ehdrp
->e_shnum
;
698 elf_numsections (abfd
) = num_sec
;
699 if (_bfd_mul_overflow (num_sec
, sizeof (i_shdrp
), &amt
))
700 goto got_wrong_format_error
;
701 elf_elfsections (abfd
) = (Elf_Internal_Shdr
**) bfd_alloc (abfd
, amt
);
702 if (!elf_elfsections (abfd
))
705 memcpy (i_shdrp
, &i_shdr
, sizeof (*i_shdrp
));
706 for (shdrp
= i_shdrp
, shindex
= 0; shindex
< num_sec
; shindex
++)
707 elf_elfsections (abfd
)[shindex
] = shdrp
++;
709 /* Read in the rest of the section header table and convert it
711 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
713 if (bfd_bread (&x_shdr
, sizeof x_shdr
, abfd
) != sizeof (x_shdr
))
715 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
717 /* Sanity check sh_link and sh_info. */
718 if (i_shdrp
[shindex
].sh_link
>= num_sec
)
720 /* PR 10478: Accept Solaris binaries with a sh_link
721 field set to SHN_BEFORE or SHN_AFTER. */
722 switch (ebd
->elf_machine_code
)
731 if (i_shdrp
[shindex
].sh_link
== (SHN_LORESERVE
& 0xffff) /* SHN_BEFORE */
732 || i_shdrp
[shindex
].sh_link
== ((SHN_LORESERVE
+ 1) & 0xffff) /* SHN_AFTER */)
734 /* Otherwise fall through. */
736 goto got_wrong_format_error
;
740 if (((i_shdrp
[shindex
].sh_flags
& SHF_INFO_LINK
)
741 || i_shdrp
[shindex
].sh_type
== SHT_RELA
742 || i_shdrp
[shindex
].sh_type
== SHT_REL
)
743 && i_shdrp
[shindex
].sh_info
>= num_sec
)
744 goto got_wrong_format_error
;
746 /* If the section is loaded, but not page aligned, clear
748 if (i_shdrp
[shindex
].sh_size
!= 0
749 && (i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
750 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
751 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
754 abfd
->flags
&= ~D_PAGED
;
757 if (i_ehdrp
->e_shstrndx
>= elf_numsections (abfd
)
758 || i_shdrp
[i_ehdrp
->e_shstrndx
].sh_type
!= SHT_STRTAB
)
761 We used to just goto got_wrong_format_error here
762 but there are binaries in existance for which this test
763 will prevent the binutils from working with them at all.
764 So we are kind, and reset the string index value to 0
765 so that at least some processing can be done. */
766 i_ehdrp
->e_shstrndx
= SHN_UNDEF
;
768 (_("warning: %pB has a corrupt string table index - ignoring"),
772 else if (i_ehdrp
->e_shstrndx
!= SHN_UNDEF
)
773 goto got_wrong_format_error
;
775 /* Read in the program headers. */
776 if (i_ehdrp
->e_phnum
== 0)
777 elf_tdata (abfd
)->phdr
= NULL
;
780 Elf_Internal_Phdr
*i_phdr
;
785 /* Check for a corrupt input file with an impossibly large number
786 of program headers. */
787 filesize
= bfd_get_file_size (abfd
);
789 && i_ehdrp
->e_phnum
> filesize
/ sizeof (Elf_External_Phdr
))
790 goto got_wrong_format_error
;
791 if (_bfd_mul_overflow (i_ehdrp
->e_phnum
, sizeof (*i_phdr
), &amt
))
792 goto got_wrong_format_error
;
793 elf_tdata (abfd
)->phdr
794 = (Elf_Internal_Phdr
*) bfd_alloc (abfd
, amt
);
795 if (elf_tdata (abfd
)->phdr
== NULL
)
797 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
799 i_phdr
= elf_tdata (abfd
)->phdr
;
800 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
802 Elf_External_Phdr x_phdr
;
804 if (bfd_bread (&x_phdr
, sizeof x_phdr
, abfd
) != sizeof x_phdr
)
806 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
810 if (i_ehdrp
->e_shstrndx
!= 0 && i_ehdrp
->e_shoff
!= 0)
812 unsigned int num_sec
;
814 /* Once all of the section headers have been read and converted, we
815 can start processing them. Note that the first section header is
816 a dummy placeholder entry, so we ignore it. */
817 num_sec
= elf_numsections (abfd
);
818 for (shindex
= 1; shindex
< num_sec
; shindex
++)
819 if (!bfd_section_from_shdr (abfd
, shindex
))
822 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
823 if (! _bfd_elf_setup_sections (abfd
))
824 goto got_wrong_format_error
;
827 /* Let the backend double check the format and override global
829 if (ebd
->elf_backend_object_p
)
831 if (! (*ebd
->elf_backend_object_p
) (abfd
))
832 goto got_wrong_format_error
;
835 /* Remember the entry point specified in the ELF file header. */
836 bfd_set_start_address (abfd
, i_ehdrp
->e_entry
);
838 /* If we have created any reloc sections that are associated with
839 debugging sections, mark the reloc sections as debugging as well. */
840 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
842 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
843 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
844 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
846 unsigned long targ_index
;
849 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
850 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
852 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
853 s
->flags
|= SEC_DEBUGGING
;
856 return _bfd_no_cleanup
;
858 got_wrong_format_error
:
859 bfd_set_error (bfd_error_wrong_format
);
865 /* ELF .o/exec file writing */
867 /* Write out the relocs. */
870 elf_write_relocs (bfd
*abfd
, asection
*sec
, void *data
)
872 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
873 bfd_boolean
*failedp
= (bfd_boolean
*) data
;
874 Elf_Internal_Shdr
*rela_hdr
;
876 void (*swap_out
) (bfd
*, const Elf_Internal_Rela
*, bfd_byte
*);
884 /* If we have already failed, don't do anything. */
888 if ((sec
->flags
& SEC_RELOC
) == 0)
891 /* The linker backend writes the relocs out itself, and sets the
892 reloc_count field to zero to inhibit writing them here. Also,
893 sometimes the SEC_RELOC flag gets set even when there aren't any
895 if (sec
->reloc_count
== 0)
898 /* If we have opened an existing file for update, reloc_count may be
899 set even though we are not linking. In that case we have nothing
901 if (sec
->orelocation
== NULL
)
904 rela_hdr
= elf_section_data (sec
)->rela
.hdr
;
905 if (rela_hdr
== NULL
)
906 rela_hdr
= elf_section_data (sec
)->rel
.hdr
;
908 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
909 if (_bfd_mul_overflow (sec
->reloc_count
, rela_hdr
->sh_entsize
, &amt
)
910 || (rela_hdr
->contents
= bfd_alloc (abfd
, amt
)) == NULL
)
912 bfd_set_error (bfd_error_no_memory
);
917 /* Figure out whether the relocations are RELA or REL relocations. */
918 if (rela_hdr
->sh_type
== SHT_RELA
)
920 swap_out
= elf_swap_reloca_out
;
921 extsize
= sizeof (Elf_External_Rela
);
923 else if (rela_hdr
->sh_type
== SHT_REL
)
925 swap_out
= elf_swap_reloc_out
;
926 extsize
= sizeof (Elf_External_Rel
);
929 /* Every relocation section should be either an SHT_RELA or an
933 /* The address of an ELF reloc is section relative for an object
934 file, and absolute for an executable file or shared library.
935 The address of a BFD reloc is always section relative. */
937 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
938 addr_offset
= sec
->vma
;
940 /* orelocation has the data, reloc_count has the count... */
943 dst_rela
= rela_hdr
->contents
;
945 for (idx
= 0; idx
< sec
->reloc_count
; idx
++, dst_rela
+= extsize
)
947 Elf_Internal_Rela src_rela
;
952 ptr
= sec
->orelocation
[idx
];
953 sym
= *ptr
->sym_ptr_ptr
;
956 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
961 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
970 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
971 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
972 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
978 if (ptr
->howto
== NULL
)
984 src_rela
.r_offset
= ptr
->address
+ addr_offset
;
985 src_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
986 src_rela
.r_addend
= ptr
->addend
;
987 (*swap_out
) (abfd
, &src_rela
, dst_rela
);
990 if (bed
->write_secondary_relocs
!= NULL
)
991 if (! bed
->write_secondary_relocs (abfd
, sec
))
998 /* Write out the program headers. */
1001 elf_write_out_phdrs (bfd
*abfd
,
1002 const Elf_Internal_Phdr
*phdr
,
1007 Elf_External_Phdr extphdr
;
1009 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
1010 if (bfd_bwrite (&extphdr
, sizeof (Elf_External_Phdr
), abfd
)
1011 != sizeof (Elf_External_Phdr
))
1018 /* Write out the section headers and the ELF file header. */
1021 elf_write_shdrs_and_ehdr (bfd
*abfd
)
1023 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1024 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1025 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1026 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1030 i_ehdrp
= elf_elfheader (abfd
);
1031 i_shdrp
= elf_elfsections (abfd
);
1033 /* swap the header before spitting it out... */
1036 elf_debug_file (i_ehdrp
);
1038 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1039 amt
= sizeof (x_ehdr
);
1040 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
1041 || bfd_bwrite (&x_ehdr
, amt
, abfd
) != amt
)
1044 /* Some fields in the first section header handle overflow of ehdr
1046 if (i_ehdrp
->e_phnum
>= PN_XNUM
)
1047 i_shdrp
[0]->sh_info
= i_ehdrp
->e_phnum
;
1048 if (i_ehdrp
->e_shnum
>= (SHN_LORESERVE
& 0xffff))
1049 i_shdrp
[0]->sh_size
= i_ehdrp
->e_shnum
;
1050 if (i_ehdrp
->e_shstrndx
>= (SHN_LORESERVE
& 0xffff))
1051 i_shdrp
[0]->sh_link
= i_ehdrp
->e_shstrndx
;
1053 /* at this point we've concocted all the ELF sections... */
1054 if (_bfd_mul_overflow (i_ehdrp
->e_shnum
, sizeof (*x_shdrp
), &amt
))
1056 bfd_set_error (bfd_error_no_memory
);
1059 x_shdrp
= (Elf_External_Shdr
*) bfd_alloc (abfd
, amt
);
1063 for (count
= 0; count
< i_ehdrp
->e_shnum
; i_shdrp
++, count
++)
1066 elf_debug_section (count
, *i_shdrp
);
1068 elf_swap_shdr_out (abfd
, *i_shdrp
, x_shdrp
+ count
);
1070 amt
= (bfd_size_type
) i_ehdrp
->e_shnum
* sizeof (*x_shdrp
);
1071 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
1072 || bfd_bwrite (x_shdrp
, amt
, abfd
) != amt
)
1075 /* need to dump the string table too... */
1081 elf_checksum_contents (bfd
*abfd
,
1082 void (*process
) (const void *, size_t, void *),
1085 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1086 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
1087 Elf_Internal_Phdr
*i_phdrp
= elf_tdata (abfd
)->phdr
;
1088 unsigned int count
, num
;
1091 Elf_External_Ehdr x_ehdr
;
1092 Elf_Internal_Ehdr i_ehdr
;
1095 i_ehdr
.e_phoff
= i_ehdr
.e_shoff
= 0;
1096 elf_swap_ehdr_out (abfd
, &i_ehdr
, &x_ehdr
);
1097 (*process
) (&x_ehdr
, sizeof x_ehdr
, arg
);
1100 num
= i_ehdrp
->e_phnum
;
1101 for (count
= 0; count
< num
; count
++)
1103 Elf_External_Phdr x_phdr
;
1104 elf_swap_phdr_out (abfd
, &i_phdrp
[count
], &x_phdr
);
1105 (*process
) (&x_phdr
, sizeof x_phdr
, arg
);
1108 num
= elf_numsections (abfd
);
1109 for (count
= 0; count
< num
; count
++)
1111 Elf_Internal_Shdr i_shdr
;
1112 Elf_External_Shdr x_shdr
;
1113 bfd_byte
*contents
, *free_contents
;
1115 i_shdr
= *i_shdrp
[count
];
1116 i_shdr
.sh_offset
= 0;
1118 elf_swap_shdr_out (abfd
, &i_shdr
, &x_shdr
);
1119 (*process
) (&x_shdr
, sizeof x_shdr
, arg
);
1121 /* Process the section's contents, if it has some.
1122 PR ld/12451: Read them in if necessary. */
1123 if (i_shdr
.sh_type
== SHT_NOBITS
)
1125 free_contents
= NULL
;
1126 contents
= i_shdr
.contents
;
1127 if (contents
== NULL
)
1131 sec
= bfd_section_from_elf_index (abfd
, count
);
1134 contents
= sec
->contents
;
1135 if (contents
== NULL
)
1137 /* Force rereading from file. */
1138 sec
->flags
&= ~SEC_IN_MEMORY
;
1139 if (!bfd_malloc_and_get_section (abfd
, sec
, &free_contents
))
1141 contents
= free_contents
;
1145 if (contents
!= NULL
)
1147 (*process
) (contents
, i_shdr
.sh_size
, arg
);
1148 if (free_contents
!= NULL
)
1149 free (free_contents
);
1157 elf_slurp_symbol_table (bfd
*abfd
, asymbol
**symptrs
, bfd_boolean dynamic
)
1159 Elf_Internal_Shdr
*hdr
;
1160 Elf_Internal_Shdr
*verhdr
;
1161 unsigned long symcount
; /* Number of external ELF symbols */
1162 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
1163 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
1164 Elf_Internal_Sym
*isym
;
1165 Elf_Internal_Sym
*isymend
;
1166 Elf_Internal_Sym
*isymbuf
= NULL
;
1167 Elf_External_Versym
*xver
;
1168 Elf_External_Versym
*xverbuf
= NULL
;
1169 const struct elf_backend_data
*ebd
;
1172 /* Read each raw ELF symbol, converting from external ELF form to
1173 internal ELF form, and then using the information to create a
1174 canonical bfd symbol table entry.
1176 Note that we allocate the initial bfd canonical symbol buffer
1177 based on a one-to-one mapping of the ELF symbols to canonical
1178 symbols. We actually use all the ELF symbols, so there will be no
1179 space left over at the end. When we have all the symbols, we
1180 build the caller's pointer vector. */
1184 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1189 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
1190 if (elf_dynversym (abfd
) == 0)
1193 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
1194 if ((elf_dynverdef (abfd
) != 0
1195 && elf_tdata (abfd
)->verdef
== NULL
)
1196 || (elf_dynverref (abfd
) != 0
1197 && elf_tdata (abfd
)->verref
== NULL
))
1199 if (!_bfd_elf_slurp_version_tables (abfd
, FALSE
))
1204 ebd
= get_elf_backend_data (abfd
);
1205 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1207 sym
= symbase
= NULL
;
1210 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, symcount
, 0,
1212 if (isymbuf
== NULL
)
1215 if (_bfd_mul_overflow (symcount
, sizeof (elf_symbol_type
), &amt
))
1217 bfd_set_error (bfd_error_file_too_big
);
1220 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, amt
);
1221 if (symbase
== (elf_symbol_type
*) NULL
)
1224 /* Read the raw ELF version symbol information. */
1226 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1229 /* xgettext:c-format */
1230 (_("%pB: version count (%" PRId64
")"
1231 " does not match symbol count (%ld)"),
1233 (int64_t) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1236 /* Slurp in the symbols without the version information,
1237 since that is more helpful than just quitting. */
1243 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1245 xverbuf
= (Elf_External_Versym
*)
1246 _bfd_malloc_and_read (abfd
, verhdr
->sh_size
, verhdr
->sh_size
);
1247 if (xverbuf
== NULL
&& verhdr
->sh_size
!= 0)
1251 /* Skip first symbol, which is a null dummy. */
1255 isymend
= isymbuf
+ symcount
;
1256 for (isym
= isymbuf
+ 1, sym
= symbase
; isym
< isymend
; isym
++, sym
++)
1258 memcpy (&sym
->internal_elf_sym
, isym
, sizeof (Elf_Internal_Sym
));
1260 sym
->symbol
.the_bfd
= abfd
;
1261 sym
->symbol
.name
= bfd_elf_sym_name (abfd
, hdr
, isym
, NULL
);
1262 sym
->symbol
.value
= isym
->st_value
;
1264 if (isym
->st_shndx
== SHN_UNDEF
)
1266 sym
->symbol
.section
= bfd_und_section_ptr
;
1268 else if (isym
->st_shndx
== SHN_ABS
)
1270 sym
->symbol
.section
= bfd_abs_section_ptr
;
1272 else if (isym
->st_shndx
== SHN_COMMON
)
1274 sym
->symbol
.section
= bfd_com_section_ptr
;
1275 if ((abfd
->flags
& BFD_PLUGIN
) != 0)
1277 asection
*xc
= bfd_get_section_by_name (abfd
, "COMMON");
1281 flagword flags
= (SEC_ALLOC
| SEC_IS_COMMON
| SEC_KEEP
1283 xc
= bfd_make_section_with_flags (abfd
, "COMMON", flags
);
1287 sym
->symbol
.section
= xc
;
1289 /* Elf puts the alignment into the `value' field, and
1290 the size into the `size' field. BFD wants to see the
1291 size in the value field, and doesn't care (at the
1292 moment) about the alignment. */
1293 sym
->symbol
.value
= isym
->st_size
;
1298 = bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1299 if (sym
->symbol
.section
== NULL
)
1301 /* This symbol is in a section for which we did not
1302 create a BFD section. Just use bfd_abs_section,
1303 although it is wrong. FIXME. Note - there is
1304 code in elf.c:swap_out_syms that calls
1305 symbol_section_index() in the elf backend for
1307 sym
->symbol
.section
= bfd_abs_section_ptr
;
1311 /* If this is a relocatable file, then the symbol value is
1312 already section relative. */
1313 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1314 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1316 switch (ELF_ST_BIND (isym
->st_info
))
1319 sym
->symbol
.flags
|= BSF_LOCAL
;
1322 if (isym
->st_shndx
!= SHN_UNDEF
&& isym
->st_shndx
!= SHN_COMMON
)
1323 sym
->symbol
.flags
|= BSF_GLOBAL
;
1326 sym
->symbol
.flags
|= BSF_WEAK
;
1328 case STB_GNU_UNIQUE
:
1329 sym
->symbol
.flags
|= BSF_GNU_UNIQUE
;
1333 switch (ELF_ST_TYPE (isym
->st_info
))
1336 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1339 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1342 sym
->symbol
.flags
|= BSF_FUNCTION
;
1345 /* FIXME: Do we have to put the size field into the value field
1346 as we do with symbols in SHN_COMMON sections (see above) ? */
1347 sym
->symbol
.flags
|= BSF_ELF_COMMON
;
1350 sym
->symbol
.flags
|= BSF_OBJECT
;
1353 sym
->symbol
.flags
|= BSF_THREAD_LOCAL
;
1356 sym
->symbol
.flags
|= BSF_RELC
;
1359 sym
->symbol
.flags
|= BSF_SRELC
;
1362 sym
->symbol
.flags
|= BSF_GNU_INDIRECT_FUNCTION
;
1367 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1371 Elf_Internal_Versym iversym
;
1373 _bfd_elf_swap_versym_in (abfd
, xver
, &iversym
);
1374 sym
->version
= iversym
.vs_vers
;
1378 /* Do some backend-specific processing on this symbol. */
1379 if (ebd
->elf_backend_symbol_processing
)
1380 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1384 /* Do some backend-specific processing on this symbol table. */
1385 if (ebd
->elf_backend_symbol_table_processing
)
1386 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1388 /* We rely on the zalloc to clear out the final symbol entry. */
1390 symcount
= sym
- symbase
;
1392 /* Fill in the user's symbol pointer vector if needed. */
1400 *symptrs
++ = &sym
->symbol
;
1403 *symptrs
= 0; /* Final null pointer */
1406 if (xverbuf
!= NULL
)
1408 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1413 if (xverbuf
!= NULL
)
1415 if (isymbuf
!= NULL
&& hdr
->contents
!= (unsigned char *) isymbuf
)
1420 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1424 elf_slurp_reloc_table_from_section (bfd
*abfd
,
1426 Elf_Internal_Shdr
*rel_hdr
,
1427 bfd_size_type reloc_count
,
1430 bfd_boolean dynamic
)
1432 const struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1433 void *allocated
= NULL
;
1434 bfd_byte
*native_relocs
;
1438 unsigned int symcount
;
1440 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0)
1442 allocated
= _bfd_malloc_and_read (abfd
, rel_hdr
->sh_size
, rel_hdr
->sh_size
);
1443 if (allocated
== NULL
)
1446 native_relocs
= (bfd_byte
*) allocated
;
1448 entsize
= rel_hdr
->sh_entsize
;
1449 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1450 || entsize
== sizeof (Elf_External_Rela
));
1453 symcount
= bfd_get_dynamic_symcount (abfd
);
1455 symcount
= bfd_get_symcount (abfd
);
1457 for (i
= 0, relent
= relents
;
1459 i
++, relent
++, native_relocs
+= entsize
)
1462 Elf_Internal_Rela rela
;
1464 if (entsize
== sizeof (Elf_External_Rela
))
1465 elf_swap_reloca_in (abfd
, native_relocs
, &rela
);
1467 elf_swap_reloc_in (abfd
, native_relocs
, &rela
);
1469 /* The address of an ELF reloc is section relative for an object
1470 file, and absolute for an executable file or shared library.
1471 The address of a normal BFD reloc is always section relative,
1472 and the address of a dynamic reloc is absolute.. */
1473 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1474 relent
->address
= rela
.r_offset
;
1476 relent
->address
= rela
.r_offset
- asect
->vma
;
1478 if (ELF_R_SYM (rela
.r_info
) == STN_UNDEF
)
1479 /* FIXME: This and the error case below mean that we have a
1480 symbol on relocs that is not elf_symbol_type. */
1481 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1482 else if (ELF_R_SYM (rela
.r_info
) > symcount
)
1485 /* xgettext:c-format */
1486 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
1487 abfd
, asect
, i
, (long) ELF_R_SYM (rela
.r_info
));
1488 bfd_set_error (bfd_error_bad_value
);
1489 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1495 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1497 relent
->sym_ptr_ptr
= ps
;
1500 relent
->addend
= rela
.r_addend
;
1502 if ((entsize
== sizeof (Elf_External_Rela
)
1503 && ebd
->elf_info_to_howto
!= NULL
)
1504 || ebd
->elf_info_to_howto_rel
== NULL
)
1505 res
= ebd
->elf_info_to_howto (abfd
, relent
, &rela
);
1507 res
= ebd
->elf_info_to_howto_rel (abfd
, relent
, &rela
);
1509 if (! res
|| relent
->howto
== NULL
)
1513 if (allocated
!= NULL
)
1518 if (allocated
!= NULL
)
1523 /* Read in and swap the external relocs. */
1526 elf_slurp_reloc_table (bfd
*abfd
,
1529 bfd_boolean dynamic
)
1531 const struct elf_backend_data
* const bed
= get_elf_backend_data (abfd
);
1532 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1533 Elf_Internal_Shdr
*rel_hdr
;
1534 Elf_Internal_Shdr
*rel_hdr2
;
1535 bfd_size_type reloc_count
;
1536 bfd_size_type reloc_count2
;
1540 if (asect
->relocation
!= NULL
)
1545 if ((asect
->flags
& SEC_RELOC
) == 0
1546 || asect
->reloc_count
== 0)
1549 rel_hdr
= d
->rel
.hdr
;
1550 reloc_count
= rel_hdr
? NUM_SHDR_ENTRIES (rel_hdr
) : 0;
1551 rel_hdr2
= d
->rela
.hdr
;
1552 reloc_count2
= rel_hdr2
? NUM_SHDR_ENTRIES (rel_hdr2
) : 0;
1554 /* PR 17512: file: 0b4f81b7. */
1555 if (asect
->reloc_count
!= reloc_count
+ reloc_count2
)
1557 BFD_ASSERT ((rel_hdr
&& asect
->rel_filepos
== rel_hdr
->sh_offset
)
1558 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1563 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1564 case because relocations against this section may use the
1565 dynamic symbol table, and in that case bfd_section_from_shdr
1566 in elf.c does not update the RELOC_COUNT. */
1567 if (asect
->size
== 0)
1570 rel_hdr
= &d
->this_hdr
;
1571 reloc_count
= NUM_SHDR_ENTRIES (rel_hdr
);
1576 if (_bfd_mul_overflow (reloc_count
+ reloc_count2
, sizeof (arelent
), &amt
))
1578 bfd_set_error (bfd_error_file_too_big
);
1581 relents
= (arelent
*) bfd_alloc (abfd
, amt
);
1582 if (relents
== NULL
)
1586 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1587 rel_hdr
, reloc_count
,
1593 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1594 rel_hdr2
, reloc_count2
,
1595 relents
+ reloc_count
,
1599 if (bed
->slurp_secondary_relocs
!= NULL
1600 && ! bed
->slurp_secondary_relocs (abfd
, asect
, symbols
))
1603 asect
->relocation
= relents
;
1609 elf_debug_section (int num
, Elf_Internal_Shdr
*hdr
)
1611 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1612 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1615 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1616 (long) hdr
->sh_name
,
1617 (long) hdr
->sh_type
,
1618 (long) hdr
->sh_flags
);
1620 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1621 (long) hdr
->sh_addr
,
1622 (long) hdr
->sh_offset
,
1623 (long) hdr
->sh_size
);
1625 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1626 (long) hdr
->sh_link
,
1627 (long) hdr
->sh_info
,
1628 (long) hdr
->sh_addralign
);
1629 fprintf (stderr
, "sh_entsize = %ld\n",
1630 (long) hdr
->sh_entsize
);
1637 elf_debug_file (Elf_Internal_Ehdr
*ehdrp
)
1639 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1640 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1641 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1642 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1643 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1644 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1645 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1649 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1650 reconstruct an ELF file by reading the segments out of remote
1651 memory based on the ELF file header at EHDR_VMA and the ELF program
1652 headers it points to. If non-zero, SIZE is the known extent of the
1653 object. If not null, *LOADBASEP is filled in with the difference
1654 between the VMAs from which the segments were read, and the VMAs
1655 the file headers (and hence BFD's idea of each section's VMA) put
1658 The function TARGET_READ_MEMORY is called to copy LEN bytes from
1659 the remote memory at target address VMA into the local buffer at
1660 MYADDR; it should return zero on success or an `errno' code on
1661 failure. TEMPL must be a BFD for a target with the word size and
1662 byte order found in the remote memory. */
1665 NAME(_bfd_elf
,bfd_from_remote_memory
)
1667 bfd_vma ehdr_vma
/* Bytes. */,
1668 bfd_size_type size
/* Octets. */,
1669 bfd_vma
*loadbasep
/* Bytes. */,
1670 int (*target_read_memory
) (bfd_vma
, bfd_byte
*, bfd_size_type
))
1671 /* (Bytes , , octets ). */
1673 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1674 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
1675 Elf_External_Phdr
*x_phdrs
;
1676 Elf_Internal_Phdr
*i_phdrs
, *last_phdr
, *first_phdr
;
1678 struct bfd_in_memory
*bim
;
1682 bfd_vma high_offset
;
1684 bfd_vma loadbase
; /* Bytes. */
1687 unsigned int opb
= bfd_octets_per_byte (templ
, NULL
);
1689 /* Read in the ELF header in external format. */
1690 err
= target_read_memory (ehdr_vma
, (bfd_byte
*) &x_ehdr
, sizeof x_ehdr
);
1693 bfd_set_error (bfd_error_system_call
);
1698 /* Now check to see if we have a valid ELF file, and one that BFD can
1699 make use of. The magic number must match, the address size ('class')
1700 and byte-swapping must match our XVEC entry. */
1702 if (! elf_file_p (&x_ehdr
)
1703 || x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
1704 || x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
)
1706 bfd_set_error (bfd_error_wrong_format
);
1710 /* Check that file's byte order matches xvec's */
1711 switch (x_ehdr
.e_ident
[EI_DATA
])
1713 case ELFDATA2MSB
: /* Big-endian */
1714 if (! bfd_header_big_endian (templ
))
1716 bfd_set_error (bfd_error_wrong_format
);
1720 case ELFDATA2LSB
: /* Little-endian */
1721 if (! bfd_header_little_endian (templ
))
1723 bfd_set_error (bfd_error_wrong_format
);
1727 case ELFDATANONE
: /* No data encoding specified */
1728 default: /* Unknown data encoding specified */
1729 bfd_set_error (bfd_error_wrong_format
);
1733 elf_swap_ehdr_in (templ
, &x_ehdr
, &i_ehdr
);
1735 /* The file header tells where to find the program headers.
1736 These are what we use to actually choose what to read. */
1738 if (i_ehdr
.e_phentsize
!= sizeof (Elf_External_Phdr
) || i_ehdr
.e_phnum
== 0)
1740 bfd_set_error (bfd_error_wrong_format
);
1744 if (_bfd_mul_overflow (i_ehdr
.e_phnum
,
1745 sizeof (*x_phdrs
) + sizeof (*i_phdrs
), &amt
))
1747 bfd_set_error (bfd_error_file_too_big
);
1750 x_phdrs
= (Elf_External_Phdr
*) bfd_malloc (amt
);
1751 if (x_phdrs
== NULL
)
1753 err
= target_read_memory (ehdr_vma
+ i_ehdr
.e_phoff
, (bfd_byte
*) x_phdrs
,
1754 i_ehdr
.e_phnum
* sizeof x_phdrs
[0]);
1758 bfd_set_error (bfd_error_system_call
);
1762 i_phdrs
= (Elf_Internal_Phdr
*) &x_phdrs
[i_ehdr
.e_phnum
];
1768 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1770 elf_swap_phdr_in (templ
, &x_phdrs
[i
], &i_phdrs
[i
]);
1771 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1773 bfd_vma segment_end
= i_phdrs
[i
].p_offset
+ i_phdrs
[i
].p_filesz
;
1775 if (segment_end
> high_offset
)
1777 high_offset
= segment_end
;
1778 last_phdr
= &i_phdrs
[i
];
1781 /* If this program header covers offset zero, where the file
1782 header sits, then we can figure out the loadbase. */
1783 if (first_phdr
== NULL
)
1785 bfd_vma p_offset
= i_phdrs
[i
].p_offset
; /* Octets. */
1786 bfd_vma p_vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1788 if (i_phdrs
[i
].p_align
> 1)
1790 p_offset
&= -(i_phdrs
[i
].p_align
* opb
);
1791 p_vaddr
&= -(i_phdrs
[i
].p_align
* opb
);
1795 loadbase
= ehdr_vma
- p_vaddr
/ opb
;
1796 first_phdr
= &i_phdrs
[i
];
1801 if (high_offset
== 0)
1803 /* There were no PT_LOAD segments, so we don't have anything to read. */
1805 bfd_set_error (bfd_error_wrong_format
);
1810 if (i_ehdr
.e_shoff
!= 0 && i_ehdr
.e_shnum
!= 0 && i_ehdr
.e_shentsize
!= 0)
1812 shdr_end
= i_ehdr
.e_shoff
+ i_ehdr
.e_shnum
* i_ehdr
.e_shentsize
;
1814 if (last_phdr
->p_filesz
!= last_phdr
->p_memsz
)
1816 /* If the last PT_LOAD header has a bss area then ld.so will
1817 have cleared anything past p_filesz, zapping the section
1820 else if (size
>= shdr_end
)
1824 bfd_vma page_size
= get_elf_backend_data (templ
)->minpagesize
;
1825 bfd_vma segment_end
= last_phdr
->p_offset
+ last_phdr
->p_filesz
;
1827 /* Assume we loaded full pages, allowing us to sometimes see
1829 if (page_size
> 1 && shdr_end
> segment_end
)
1831 bfd_vma page_end
= (segment_end
+ page_size
- 1) & -page_size
;
1833 if (page_end
>= shdr_end
)
1834 /* Whee, section headers covered. */
1835 high_offset
= shdr_end
;
1840 /* Now we know the size of the whole image we want read in. */
1841 contents
= (bfd_byte
*) bfd_zmalloc (high_offset
);
1842 if (contents
== NULL
)
1848 for (i
= 0; i
< i_ehdr
.e_phnum
; ++i
)
1849 if (i_phdrs
[i
].p_type
== PT_LOAD
)
1851 bfd_vma start
= i_phdrs
[i
].p_offset
; /* Octets. */
1852 bfd_vma end
= start
+ i_phdrs
[i
].p_filesz
; /* Octets. */
1853 bfd_vma vaddr
= i_phdrs
[i
].p_vaddr
; /* Octets. */
1855 /* Extend the beginning of the first pt_load to cover file
1856 header and program headers, if we proved earlier that its
1857 aligned offset is 0. */
1858 if (first_phdr
== &i_phdrs
[i
])
1863 /* Extend the end of the last pt_load to cover section headers. */
1864 if (last_phdr
== &i_phdrs
[i
])
1866 err
= target_read_memory (loadbase
+ vaddr
/ opb
,
1867 contents
+ start
, end
- start
);
1872 bfd_set_error (bfd_error_system_call
);
1879 /* If the segments visible in memory didn't include the section headers,
1880 then clear them from the file header. */
1881 if (high_offset
< shdr_end
)
1883 memset (&x_ehdr
.e_shoff
, 0, sizeof x_ehdr
.e_shoff
);
1884 memset (&x_ehdr
.e_shnum
, 0, sizeof x_ehdr
.e_shnum
);
1885 memset (&x_ehdr
.e_shstrndx
, 0, sizeof x_ehdr
.e_shstrndx
);
1888 /* This will normally have been in the first PT_LOAD segment. But it
1889 conceivably could be missing, and we might have just changed it. */
1890 memcpy (contents
, &x_ehdr
, sizeof x_ehdr
);
1892 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1893 bim
= (struct bfd_in_memory
*) bfd_malloc (sizeof (struct bfd_in_memory
));
1899 filename
= bfd_strdup ("<in-memory>");
1900 if (filename
== NULL
)
1906 nbfd
= _bfd_new_bfd ();
1914 nbfd
->filename
= filename
;
1915 nbfd
->xvec
= templ
->xvec
;
1916 bim
->size
= high_offset
;
1917 bim
->buffer
= contents
;
1918 nbfd
->iostream
= bim
;
1919 nbfd
->flags
= BFD_IN_MEMORY
;
1920 nbfd
->iovec
= &_bfd_memory_iovec
;
1922 nbfd
->direction
= read_direction
;
1923 nbfd
->mtime
= time (NULL
);
1924 nbfd
->mtime_set
= TRUE
;
1927 *loadbasep
= loadbase
;
1931 /* Function for ELF_R_INFO. */
1934 NAME(elf
,r_info
) (bfd_vma sym
, bfd_vma type
)
1936 return ELF_R_INFO (sym
, type
);
1939 /* Function for ELF_R_SYM. */
1942 NAME(elf
,r_sym
) (bfd_vma r_info
)
1944 return ELF_R_SYM (r_info
);
1947 #include "elfcore.h"
1949 /* Size-dependent data and functions. */
1950 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1951 sizeof (Elf_External_Ehdr
),
1952 sizeof (Elf_External_Phdr
),
1953 sizeof (Elf_External_Shdr
),
1954 sizeof (Elf_External_Rel
),
1955 sizeof (Elf_External_Rela
),
1956 sizeof (Elf_External_Sym
),
1957 sizeof (Elf_External_Dyn
),
1958 sizeof (Elf_External_Note
),
1961 ARCH_SIZE
, LOG_FILE_ALIGN
,
1962 ELFCLASS
, EV_CURRENT
,
1963 elf_write_out_phdrs
,
1964 elf_write_shdrs_and_ehdr
,
1965 elf_checksum_contents
,
1968 elf_swap_symbol_out
,
1969 elf_slurp_reloc_table
,
1970 elf_slurp_symbol_table
,