daily update
[binutils.git] / bfd / elfcode.h
blobb42229f007b7ea136a6f226b281d2634d1e8b328
1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 Written by Fred Fish @ Cygnus Support, from information published
7 in "UNIX System V Release 4, Programmers Guide: ANSI C and
8 Programming Support Tools". Sufficient support for gdb.
10 Rewritten by Mark Eichin @ Cygnus Support, from information
11 published in "System V Application Binary Interface", chapters 4
12 and 5, as well as the various "Processor Supplement" documents
13 derived from it. Added support for assembler and other object file
14 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
15 Meissner (Open Software Foundation), and Peter Hoogenboom (University
16 of Utah) to finish and extend this.
18 This file is part of BFD, the Binary File Descriptor library.
20 This program is free software; you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation; either version 3 of the License, or
23 (at your option) any later version.
25 This program is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
30 You should have received a copy of the GNU General Public License
31 along with this program; if not, write to the Free Software
32 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
33 MA 02110-1301, USA. */
36 /* Problems and other issues to resolve.
38 (1) BFD expects there to be some fixed number of "sections" in
39 the object file. I.E. there is a "section_count" variable in the
40 bfd structure which contains the number of sections. However, ELF
41 supports multiple "views" of a file. In particular, with current
42 implementations, executable files typically have two tables, a
43 program header table and a section header table, both of which
44 partition the executable.
46 In ELF-speak, the "linking view" of the file uses the section header
47 table to access "sections" within the file, and the "execution view"
48 uses the program header table to access "segments" within the file.
49 "Segments" typically may contain all the data from one or more
50 "sections".
52 Note that the section header table is optional in ELF executables,
53 but it is this information that is most useful to gdb. If the
54 section header table is missing, then gdb should probably try
55 to make do with the program header table. (FIXME)
57 (2) The code in this file is compiled twice, once in 32-bit mode and
58 once in 64-bit mode. More of it should be made size-independent
59 and moved into elf.c.
61 (3) ELF section symbols are handled rather sloppily now. This should
62 be cleaned up, and ELF section symbols reconciled with BFD section
63 symbols.
65 (4) We need a published spec for 64-bit ELF. We've got some stuff here
66 that we're using for SPARC V9 64-bit chips, but don't assume that
67 it's cast in stone.
70 #include "sysdep.h"
71 #include "bfd.h"
72 #include "libiberty.h"
73 #include "bfdlink.h"
74 #include "libbfd.h"
75 #include "elf-bfd.h"
77 /* Renaming structures, typedefs, macros and functions to be size-specific. */
78 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
79 #define Elf_External_Sym NAME(Elf,External_Sym)
80 #define Elf_External_Shdr NAME(Elf,External_Shdr)
81 #define Elf_External_Phdr NAME(Elf,External_Phdr)
82 #define Elf_External_Rel NAME(Elf,External_Rel)
83 #define Elf_External_Rela NAME(Elf,External_Rela)
84 #define Elf_External_Dyn NAME(Elf,External_Dyn)
86 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
87 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
88 #define elf_core_file_matches_executable_p \
89 NAME(bfd_elf,core_file_matches_executable_p)
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)
129 #if ARCH_SIZE == 64
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
134 #define FILE_ALIGN 8
135 #define LOG_FILE_ALIGN 3
136 #endif
137 #if ARCH_SIZE == 32
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
142 #define FILE_ALIGN 4
143 #define LOG_FILE_ALIGN 2
144 #endif
146 #if DEBUG & 2
147 static void elf_debug_section (int, Elf_Internal_Shdr *);
148 #endif
149 #if DEBUG & 1
150 static void elf_debug_file (Elf_Internal_Ehdr *);
151 #endif
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". */
157 #if ARCH_SIZE == 64
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
162 #endif
163 #if ARCH_SIZE == 32
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
168 #endif
170 /* Translate an ELF symbol in external format into an ELF symbol in internal
171 format. */
173 bfd_boolean
174 elf_swap_symbol_in (bfd *abfd,
175 const void *psrc,
176 const void *pshn,
177 Elf_Internal_Sym *dst)
179 const Elf_External_Sym *src = psrc;
180 const Elf_External_Sym_Shndx *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);
184 if (signed_vma)
185 dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
186 else
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))
194 if (shndx == NULL)
195 return FALSE;
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 return TRUE;
203 /* Translate an ELF symbol in internal format into an ELF symbol in external
204 format. */
206 void
207 elf_swap_symbol_out (bfd *abfd,
208 const Elf_Internal_Sym *src,
209 void *cdst,
210 void *shndx)
212 unsigned int tmp;
213 Elf_External_Sym *dst = cdst;
214 H_PUT_32 (abfd, src->st_name, dst->st_name);
215 H_PUT_WORD (abfd, src->st_value, dst->st_value);
216 H_PUT_WORD (abfd, src->st_size, dst->st_size);
217 H_PUT_8 (abfd, src->st_info, dst->st_info);
218 H_PUT_8 (abfd, src->st_other, dst->st_other);
219 tmp = src->st_shndx;
220 if (tmp >= (SHN_LORESERVE & 0xffff) && tmp < SHN_LORESERVE)
222 if (shndx == NULL)
223 abort ();
224 H_PUT_32 (abfd, tmp, shndx);
225 tmp = SHN_XINDEX & 0xffff;
227 H_PUT_16 (abfd, tmp, dst->st_shndx);
230 /* Translate an ELF file header in external format into an ELF file header in
231 internal format. */
233 static void
234 elf_swap_ehdr_in (bfd *abfd,
235 const Elf_External_Ehdr *src,
236 Elf_Internal_Ehdr *dst)
238 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
239 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
240 dst->e_type = H_GET_16 (abfd, src->e_type);
241 dst->e_machine = H_GET_16 (abfd, src->e_machine);
242 dst->e_version = H_GET_32 (abfd, src->e_version);
243 if (signed_vma)
244 dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
245 else
246 dst->e_entry = H_GET_WORD (abfd, src->e_entry);
247 dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
248 dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
249 dst->e_flags = H_GET_32 (abfd, src->e_flags);
250 dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
251 dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
252 dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
253 dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
254 dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
255 dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
258 /* Translate an ELF file header in internal format into an ELF file header in
259 external format. */
261 static void
262 elf_swap_ehdr_out (bfd *abfd,
263 const Elf_Internal_Ehdr *src,
264 Elf_External_Ehdr *dst)
266 unsigned int tmp;
267 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
268 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
269 /* note that all elements of dst are *arrays of unsigned char* already... */
270 H_PUT_16 (abfd, src->e_type, dst->e_type);
271 H_PUT_16 (abfd, src->e_machine, dst->e_machine);
272 H_PUT_32 (abfd, src->e_version, dst->e_version);
273 if (signed_vma)
274 H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
275 else
276 H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
277 H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
278 H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
279 H_PUT_32 (abfd, src->e_flags, dst->e_flags);
280 H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
281 H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
282 H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
283 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
284 tmp = src->e_shnum;
285 if (tmp >= (SHN_LORESERVE & 0xffff))
286 tmp = SHN_UNDEF;
287 H_PUT_16 (abfd, tmp, dst->e_shnum);
288 tmp = src->e_shstrndx;
289 if (tmp >= (SHN_LORESERVE & 0xffff))
290 tmp = SHN_XINDEX & 0xffff;
291 H_PUT_16 (abfd, tmp, dst->e_shstrndx);
294 /* Translate an ELF section header table entry in external format into an
295 ELF section header table entry in internal format. */
297 static void
298 elf_swap_shdr_in (bfd *abfd,
299 const Elf_External_Shdr *src,
300 Elf_Internal_Shdr *dst)
302 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
304 dst->sh_name = H_GET_32 (abfd, src->sh_name);
305 dst->sh_type = H_GET_32 (abfd, src->sh_type);
306 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
307 if (signed_vma)
308 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
309 else
310 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
311 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
312 dst->sh_size = H_GET_WORD (abfd, src->sh_size);
313 dst->sh_link = H_GET_32 (abfd, src->sh_link);
314 dst->sh_info = H_GET_32 (abfd, src->sh_info);
315 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
316 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
317 dst->bfd_section = NULL;
318 dst->contents = NULL;
321 /* Translate an ELF section header table entry in internal format into an
322 ELF section header table entry in external format. */
324 static void
325 elf_swap_shdr_out (bfd *abfd,
326 const Elf_Internal_Shdr *src,
327 Elf_External_Shdr *dst)
329 /* note that all elements of dst are *arrays of unsigned char* already... */
330 H_PUT_32 (abfd, src->sh_name, dst->sh_name);
331 H_PUT_32 (abfd, src->sh_type, dst->sh_type);
332 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
333 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
334 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
335 H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
336 H_PUT_32 (abfd, src->sh_link, dst->sh_link);
337 H_PUT_32 (abfd, src->sh_info, dst->sh_info);
338 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
339 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
342 /* Translate an ELF program header table entry in external format into an
343 ELF program header table entry in internal format. */
345 void
346 elf_swap_phdr_in (bfd *abfd,
347 const Elf_External_Phdr *src,
348 Elf_Internal_Phdr *dst)
350 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
352 dst->p_type = H_GET_32 (abfd, src->p_type);
353 dst->p_flags = H_GET_32 (abfd, src->p_flags);
354 dst->p_offset = H_GET_WORD (abfd, src->p_offset);
355 if (signed_vma)
357 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
358 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
360 else
362 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
363 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
365 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
366 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
367 dst->p_align = H_GET_WORD (abfd, src->p_align);
370 void
371 elf_swap_phdr_out (bfd *abfd,
372 const Elf_Internal_Phdr *src,
373 Elf_External_Phdr *dst)
375 const struct elf_backend_data *bed;
376 bfd_vma p_paddr;
378 bed = get_elf_backend_data (abfd);
379 p_paddr = bed->want_p_paddr_set_to_zero ? 0 : src->p_paddr;
381 /* note that all elements of dst are *arrays of unsigned char* already... */
382 H_PUT_32 (abfd, src->p_type, dst->p_type);
383 H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
384 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
385 H_PUT_WORD (abfd, p_paddr, dst->p_paddr);
386 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
387 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
388 H_PUT_32 (abfd, src->p_flags, dst->p_flags);
389 H_PUT_WORD (abfd, src->p_align, dst->p_align);
392 /* Translate an ELF reloc from external format to internal format. */
393 void
394 elf_swap_reloc_in (bfd *abfd,
395 const bfd_byte *s,
396 Elf_Internal_Rela *dst)
398 const Elf_External_Rel *src = (const Elf_External_Rel *) s;
399 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
400 dst->r_info = H_GET_WORD (abfd, src->r_info);
401 dst->r_addend = 0;
404 void
405 elf_swap_reloca_in (bfd *abfd,
406 const bfd_byte *s,
407 Elf_Internal_Rela *dst)
409 const Elf_External_Rela *src = (const Elf_External_Rela *) s;
410 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
411 dst->r_info = H_GET_WORD (abfd, src->r_info);
412 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
415 /* Translate an ELF reloc from internal format to external format. */
416 void
417 elf_swap_reloc_out (bfd *abfd,
418 const Elf_Internal_Rela *src,
419 bfd_byte *d)
421 Elf_External_Rel *dst = (Elf_External_Rel *) d;
422 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
423 H_PUT_WORD (abfd, src->r_info, dst->r_info);
426 void
427 elf_swap_reloca_out (bfd *abfd,
428 const Elf_Internal_Rela *src,
429 bfd_byte *d)
431 Elf_External_Rela *dst = (Elf_External_Rela *) d;
432 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
433 H_PUT_WORD (abfd, src->r_info, dst->r_info);
434 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
437 void
438 elf_swap_dyn_in (bfd *abfd,
439 const void *p,
440 Elf_Internal_Dyn *dst)
442 const Elf_External_Dyn *src = p;
444 dst->d_tag = H_GET_WORD (abfd, src->d_tag);
445 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
448 void
449 elf_swap_dyn_out (bfd *abfd,
450 const Elf_Internal_Dyn *src,
451 void *p)
453 Elf_External_Dyn *dst = p;
455 H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
456 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
459 /* ELF .o/exec file reading */
461 /* Begin processing a given object.
463 First we validate the file by reading in the ELF header and checking
464 the magic number. */
466 static inline bfd_boolean
467 elf_file_p (Elf_External_Ehdr *x_ehdrp)
469 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
470 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
471 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
472 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
475 /* Check to see if the file associated with ABFD matches the target vector
476 that ABFD points to.
478 Note that we may be called several times with the same ABFD, but different
479 target vectors, most of which will not match. We have to avoid leaving
480 any side effects in ABFD, or any data it points to (like tdata), if the
481 file does not match the target vector. */
483 const bfd_target *
484 elf_object_p (bfd *abfd)
486 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
487 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
488 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
489 Elf_Internal_Shdr i_shdr;
490 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
491 unsigned int shindex;
492 const struct elf_backend_data *ebd;
493 struct bfd_preserve preserve;
494 asection *s;
495 bfd_size_type amt;
496 const bfd_target *target;
497 const bfd_target * const *target_ptr;
499 preserve.marker = NULL;
501 /* Read in the ELF header in external format. */
503 if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
505 if (bfd_get_error () != bfd_error_system_call)
506 goto got_wrong_format_error;
507 else
508 goto got_no_match;
511 /* Now check to see if we have a valid ELF file, and one that BFD can
512 make use of. The magic number must match, the address size ('class')
513 and byte-swapping must match our XVEC entry, and it must have a
514 section header table (FIXME: See comments re sections at top of this
515 file). */
517 if (! elf_file_p (&x_ehdr)
518 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
519 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
520 goto got_wrong_format_error;
522 /* Check that file's byte order matches xvec's */
523 switch (x_ehdr.e_ident[EI_DATA])
525 case ELFDATA2MSB: /* Big-endian */
526 if (! bfd_header_big_endian (abfd))
527 goto got_wrong_format_error;
528 break;
529 case ELFDATA2LSB: /* Little-endian */
530 if (! bfd_header_little_endian (abfd))
531 goto got_wrong_format_error;
532 break;
533 case ELFDATANONE: /* No data encoding specified */
534 default: /* Unknown data encoding specified */
535 goto got_wrong_format_error;
538 if (!bfd_preserve_save (abfd, &preserve))
539 goto got_no_match;
541 target = abfd->xvec;
543 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
544 the tdata pointer in the bfd. */
546 if (! (*target->_bfd_set_format[bfd_object]) (abfd))
547 goto got_no_match;
548 preserve.marker = elf_tdata (abfd);
550 /* Now that we know the byte order, swap in the rest of the header */
551 i_ehdrp = elf_elfheader (abfd);
552 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
553 #if DEBUG & 1
554 elf_debug_file (i_ehdrp);
555 #endif
557 /* Reject ET_CORE (header indicates core file, not object file) */
558 if (i_ehdrp->e_type == ET_CORE)
559 goto got_wrong_format_error;
561 /* If this is a relocatable file and there is no section header
562 table, then we're hosed. */
563 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
564 goto got_wrong_format_error;
566 /* As a simple sanity check, verify that what BFD thinks is the
567 size of each section header table entry actually matches the size
568 recorded in the file, but only if there are any sections. */
569 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
570 goto got_wrong_format_error;
572 /* Further sanity check. */
573 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
574 goto got_wrong_format_error;
576 ebd = get_elf_backend_data (abfd);
577 if (ebd->s->arch_size != ARCH_SIZE)
578 goto got_wrong_format_error;
580 /* Check that the ELF e_machine field matches what this particular
581 BFD format expects. */
582 if (ebd->elf_machine_code != i_ehdrp->e_machine
583 && (ebd->elf_machine_alt1 == 0
584 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
585 && (ebd->elf_machine_alt2 == 0
586 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
588 if (ebd->elf_machine_code != EM_NONE)
589 goto got_wrong_format_error;
591 /* This is the generic ELF target. Let it match any ELF target
592 for which we do not have a specific backend. */
593 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
595 const struct elf_backend_data *back;
597 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
598 continue;
599 back = xvec_get_elf_backend_data (*target_ptr);
600 if (back->s->arch_size != ARCH_SIZE)
601 continue;
602 if (back->elf_machine_code == i_ehdrp->e_machine
603 || (back->elf_machine_alt1 != 0
604 && back->elf_machine_alt1 == i_ehdrp->e_machine)
605 || (back->elf_machine_alt2 != 0
606 && back->elf_machine_alt2 == i_ehdrp->e_machine))
608 /* target_ptr is an ELF backend which matches this
609 object file, so reject the generic ELF target. */
610 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)
627 goto got_no_match;
630 if (ebd->elf_machine_code != EM_NONE
631 && i_ehdrp->e_ident[EI_OSABI] != ebd->elf_osabi)
633 if (ebd->elf_osabi != ELFOSABI_NONE)
634 goto got_wrong_format_error;
636 /* This is an ELFOSABI_NONE ELF target. Let it match any ELF
637 target of the compatible machine for which we do not have a
638 backend with matching ELFOSABI. */
639 for (target_ptr = bfd_target_vector;
640 *target_ptr != NULL;
641 target_ptr++)
643 const struct elf_backend_data *back;
645 /* Skip this target and targets with incompatible byte
646 order. */
647 if (*target_ptr == target
648 || (*target_ptr)->flavour != bfd_target_elf_flavour
649 || (*target_ptr)->byteorder != target->byteorder
650 || ((*target_ptr)->header_byteorder
651 != target->header_byteorder))
652 continue;
654 back = xvec_get_elf_backend_data (*target_ptr);
655 if (back->elf_osabi == i_ehdrp->e_ident[EI_OSABI]
656 && (back->elf_machine_code == i_ehdrp->e_machine
657 || (back->elf_machine_alt1 != 0
658 && back->elf_machine_alt1 == i_ehdrp->e_machine)
659 || (back->elf_machine_alt2 != 0
660 && back->elf_machine_alt2 == i_ehdrp->e_machine)))
662 /* target_ptr is an ELF backend which matches this
663 object file, so reject the ELFOSABI_NONE ELF target. */
664 goto got_wrong_format_error;
669 if (i_ehdrp->e_shoff != 0)
671 bfd_signed_vma where = i_ehdrp->e_shoff;
673 if (where != (file_ptr) where)
674 goto got_wrong_format_error;
676 /* Seek to the section header table in the file. */
677 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
678 goto got_no_match;
680 /* Read the first section header at index 0, and convert to internal
681 form. */
682 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
683 goto got_no_match;
684 elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
686 /* If the section count is zero, the actual count is in the first
687 section header. */
688 if (i_ehdrp->e_shnum == SHN_UNDEF)
690 i_ehdrp->e_shnum = i_shdr.sh_size;
691 if (i_ehdrp->e_shnum != i_shdr.sh_size
692 || i_ehdrp->e_shnum == 0)
693 goto got_wrong_format_error;
696 /* And similarly for the string table index. */
697 if (i_ehdrp->e_shstrndx == (SHN_XINDEX & 0xffff))
699 i_ehdrp->e_shstrndx = i_shdr.sh_link;
700 if (i_ehdrp->e_shstrndx != i_shdr.sh_link)
701 goto got_wrong_format_error;
704 /* Sanity check that we can read all of the section headers.
705 It ought to be good enough to just read the last one. */
706 if (i_ehdrp->e_shnum != 1)
708 /* Check that we don't have a totally silly number of sections. */
709 if (i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (x_shdr)
710 || i_ehdrp->e_shnum > (unsigned int) -1 / sizeof (i_shdr))
711 goto got_wrong_format_error;
713 where += (i_ehdrp->e_shnum - 1) * sizeof (x_shdr);
714 if (where != (file_ptr) where)
715 goto got_wrong_format_error;
716 if ((bfd_size_type) where <= i_ehdrp->e_shoff)
717 goto got_wrong_format_error;
719 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
720 goto got_no_match;
721 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
722 goto got_no_match;
724 /* Back to where we were. */
725 where = i_ehdrp->e_shoff + sizeof (x_shdr);
726 if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
727 goto got_no_match;
731 /* Allocate space for a copy of the section header table in
732 internal form. */
733 if (i_ehdrp->e_shnum != 0)
735 Elf_Internal_Shdr *shdrp;
736 unsigned int num_sec;
738 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
739 i_shdrp = bfd_alloc (abfd, amt);
740 if (!i_shdrp)
741 goto got_no_match;
742 num_sec = i_ehdrp->e_shnum;
743 elf_numsections (abfd) = num_sec;
744 amt = sizeof (i_shdrp) * num_sec;
745 elf_elfsections (abfd) = bfd_alloc (abfd, amt);
746 if (!elf_elfsections (abfd))
747 goto got_no_match;
749 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
750 for (shdrp = i_shdrp, shindex = 0; shindex < num_sec; shindex++)
751 elf_elfsections (abfd)[shindex] = shdrp++;
753 /* Read in the rest of the section header table and convert it
754 to internal form. */
755 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
757 if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
758 goto got_no_match;
759 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
761 /* Sanity check sh_link and sh_info. */
762 if (i_shdrp[shindex].sh_link >= num_sec)
763 goto got_wrong_format_error;
765 if (((i_shdrp[shindex].sh_flags & SHF_INFO_LINK)
766 || i_shdrp[shindex].sh_type == SHT_RELA
767 || i_shdrp[shindex].sh_type == SHT_REL)
768 && i_shdrp[shindex].sh_info >= num_sec)
769 goto got_wrong_format_error;
771 /* If the section is loaded, but not page aligned, clear
772 D_PAGED. */
773 if (i_shdrp[shindex].sh_size != 0
774 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
775 && i_shdrp[shindex].sh_type != SHT_NOBITS
776 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
777 % ebd->minpagesize)
778 != 0))
779 abfd->flags &= ~D_PAGED;
783 /* A further sanity check. */
784 if (i_ehdrp->e_shnum != 0)
786 if (i_ehdrp->e_shstrndx >= elf_numsections (abfd))
788 /* PR 2257:
789 We used to just goto got_wrong_format_error here
790 but there are binaries in existance for which this test
791 will prevent the binutils from working with them at all.
792 So we are kind, and reset the string index value to 0
793 so that at least some processing can be done. */
794 i_ehdrp->e_shstrndx = SHN_UNDEF;
795 _bfd_error_handler (_("warning: %s has a corrupt string table index - ignoring"), abfd->filename);
798 else if (i_ehdrp->e_shstrndx != SHN_UNDEF)
799 goto got_wrong_format_error;
801 /* Read in the program headers. */
802 if (i_ehdrp->e_phnum == 0)
803 elf_tdata (abfd)->phdr = NULL;
804 else
806 Elf_Internal_Phdr *i_phdr;
807 unsigned int i;
809 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
810 elf_tdata (abfd)->phdr = bfd_alloc (abfd, amt);
811 if (elf_tdata (abfd)->phdr == NULL)
812 goto got_no_match;
813 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
814 goto got_no_match;
815 i_phdr = elf_tdata (abfd)->phdr;
816 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
818 Elf_External_Phdr x_phdr;
820 if (bfd_bread (&x_phdr, sizeof x_phdr, abfd) != sizeof x_phdr)
821 goto got_no_match;
822 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
826 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff != 0)
828 unsigned int num_sec;
830 /* Once all of the section headers have been read and converted, we
831 can start processing them. Note that the first section header is
832 a dummy placeholder entry, so we ignore it. */
833 num_sec = elf_numsections (abfd);
834 for (shindex = 1; shindex < num_sec; shindex++)
835 if (!bfd_section_from_shdr (abfd, shindex))
836 goto got_no_match;
838 /* Set up ELF sections for SHF_GROUP and SHF_LINK_ORDER. */
839 if (! _bfd_elf_setup_sections (abfd))
840 goto got_wrong_format_error;
843 /* Let the backend double check the format and override global
844 information. */
845 if (ebd->elf_backend_object_p)
847 if (! (*ebd->elf_backend_object_p) (abfd))
848 goto got_wrong_format_error;
851 /* Remember the entry point specified in the ELF file header. */
852 bfd_set_start_address (abfd, i_ehdrp->e_entry);
854 /* If we have created any reloc sections that are associated with
855 debugging sections, mark the reloc sections as debugging as well. */
856 for (s = abfd->sections; s != NULL; s = s->next)
858 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
859 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
860 && elf_section_data (s)->this_hdr.sh_info > 0)
862 unsigned long targ_index;
863 asection *targ_sec;
865 targ_index = elf_section_data (s)->this_hdr.sh_info;
866 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
867 if (targ_sec != NULL
868 && (targ_sec->flags & SEC_DEBUGGING) != 0)
869 s->flags |= SEC_DEBUGGING;
873 bfd_preserve_finish (abfd, &preserve);
874 return target;
876 got_wrong_format_error:
877 /* There is way too much undoing of half-known state here. The caller,
878 bfd_check_format_matches, really shouldn't iterate on live bfd's to
879 check match/no-match like it does. We have to rely on that a call to
880 bfd_default_set_arch_mach with the previously known mach, undoes what
881 was done by the first bfd_default_set_arch_mach (with mach 0) here.
882 For this to work, only elf-data and the mach may be changed by the
883 target-specific elf_backend_object_p function. Note that saving the
884 whole bfd here and restoring it would be even worse; the first thing
885 you notice is that the cached bfd file position gets out of sync. */
886 bfd_set_error (bfd_error_wrong_format);
888 got_no_match:
889 if (preserve.marker != NULL)
890 bfd_preserve_restore (abfd, &preserve);
891 return NULL;
894 /* ELF .o/exec file writing */
896 /* Write out the relocs. */
898 void
899 elf_write_relocs (bfd *abfd, asection *sec, void *data)
901 bfd_boolean *failedp = data;
902 Elf_Internal_Shdr *rela_hdr;
903 bfd_vma addr_offset;
904 void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
905 size_t extsize;
906 bfd_byte *dst_rela;
907 unsigned int idx;
908 asymbol *last_sym;
909 int last_sym_idx;
911 /* If we have already failed, don't do anything. */
912 if (*failedp)
913 return;
915 if ((sec->flags & SEC_RELOC) == 0)
916 return;
918 /* The linker backend writes the relocs out itself, and sets the
919 reloc_count field to zero to inhibit writing them here. Also,
920 sometimes the SEC_RELOC flag gets set even when there aren't any
921 relocs. */
922 if (sec->reloc_count == 0)
923 return;
925 /* If we have opened an existing file for update, reloc_count may be
926 set even though we are not linking. In that case we have nothing
927 to do. */
928 if (sec->orelocation == NULL)
929 return;
931 rela_hdr = &elf_section_data (sec)->rel_hdr;
933 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
934 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
935 if (rela_hdr->contents == NULL)
937 *failedp = TRUE;
938 return;
941 /* Figure out whether the relocations are RELA or REL relocations. */
942 if (rela_hdr->sh_type == SHT_RELA)
944 swap_out = elf_swap_reloca_out;
945 extsize = sizeof (Elf_External_Rela);
947 else if (rela_hdr->sh_type == SHT_REL)
949 swap_out = elf_swap_reloc_out;
950 extsize = sizeof (Elf_External_Rel);
952 else
953 /* Every relocation section should be either an SHT_RELA or an
954 SHT_REL section. */
955 abort ();
957 /* The address of an ELF reloc is section relative for an object
958 file, and absolute for an executable file or shared library.
959 The address of a BFD reloc is always section relative. */
960 addr_offset = 0;
961 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
962 addr_offset = sec->vma;
964 /* orelocation has the data, reloc_count has the count... */
965 last_sym = 0;
966 last_sym_idx = 0;
967 dst_rela = rela_hdr->contents;
969 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
971 Elf_Internal_Rela src_rela;
972 arelent *ptr;
973 asymbol *sym;
974 int n;
976 ptr = sec->orelocation[idx];
977 sym = *ptr->sym_ptr_ptr;
978 if (sym == last_sym)
979 n = last_sym_idx;
980 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
981 n = STN_UNDEF;
982 else
984 last_sym = sym;
985 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
986 if (n < 0)
988 *failedp = TRUE;
989 return;
991 last_sym_idx = n;
994 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
995 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
996 && ! _bfd_elf_validate_reloc (abfd, ptr))
998 *failedp = TRUE;
999 return;
1002 src_rela.r_offset = ptr->address + addr_offset;
1003 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
1004 src_rela.r_addend = ptr->addend;
1005 (*swap_out) (abfd, &src_rela, dst_rela);
1009 /* Write out the program headers. */
1012 elf_write_out_phdrs (bfd *abfd,
1013 const Elf_Internal_Phdr *phdr,
1014 unsigned int count)
1016 while (count--)
1018 Elf_External_Phdr extphdr;
1019 elf_swap_phdr_out (abfd, phdr, &extphdr);
1020 if (bfd_bwrite (&extphdr, sizeof (Elf_External_Phdr), abfd)
1021 != sizeof (Elf_External_Phdr))
1022 return -1;
1023 phdr++;
1025 return 0;
1028 /* Write out the section headers and the ELF file header. */
1030 bfd_boolean
1031 elf_write_shdrs_and_ehdr (bfd *abfd)
1033 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1034 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
1035 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
1036 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
1037 unsigned int count;
1038 bfd_size_type amt;
1040 i_ehdrp = elf_elfheader (abfd);
1041 i_shdrp = elf_elfsections (abfd);
1043 /* swap the header before spitting it out... */
1045 #if DEBUG & 1
1046 elf_debug_file (i_ehdrp);
1047 #endif
1048 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1049 amt = sizeof (x_ehdr);
1050 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1051 || bfd_bwrite (&x_ehdr, amt, abfd) != amt)
1052 return FALSE;
1054 /* Some fields in the first section header handle overflow of ehdr
1055 fields. */
1056 if (i_ehdrp->e_shnum >= (SHN_LORESERVE & 0xffff))
1057 i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1058 if (i_ehdrp->e_shstrndx >= (SHN_LORESERVE & 0xffff))
1059 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1061 /* at this point we've concocted all the ELF sections... */
1062 amt = i_ehdrp->e_shnum;
1063 amt *= sizeof (*x_shdrp);
1064 x_shdrp = bfd_alloc (abfd, amt);
1065 if (!x_shdrp)
1066 return FALSE;
1068 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1070 #if DEBUG & 2
1071 elf_debug_section (count, *i_shdrp);
1072 #endif
1073 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1075 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1076 || bfd_bwrite (x_shdrp, amt, abfd) != amt)
1077 return FALSE;
1079 /* need to dump the string table too... */
1081 return TRUE;
1084 bfd_boolean
1085 elf_checksum_contents (bfd *abfd,
1086 void (*process) (const void *, size_t, void *),
1087 void *arg)
1089 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
1090 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
1091 Elf_Internal_Phdr *i_phdrp = elf_tdata (abfd)->phdr;
1092 unsigned int count, num;
1095 Elf_External_Ehdr x_ehdr;
1096 Elf_Internal_Ehdr i_ehdr;
1098 i_ehdr = *i_ehdrp;
1099 i_ehdr.e_phoff = i_ehdr.e_shoff = 0;
1100 elf_swap_ehdr_out (abfd, &i_ehdr, &x_ehdr);
1101 (*process) (&x_ehdr, sizeof x_ehdr, arg);
1104 num = i_ehdrp->e_phnum;
1105 for (count = 0; count < num; count++)
1107 Elf_External_Phdr x_phdr;
1108 elf_swap_phdr_out (abfd, &i_phdrp[count], &x_phdr);
1109 (*process) (&x_phdr, sizeof x_phdr, arg);
1112 num = elf_numsections (abfd);
1113 for (count = 0; count < num; count++)
1115 Elf_Internal_Shdr i_shdr;
1116 Elf_External_Shdr x_shdr;
1118 i_shdr = *i_shdrp[count];
1119 i_shdr.sh_offset = 0;
1121 elf_swap_shdr_out (abfd, &i_shdr, &x_shdr);
1122 (*process) (&x_shdr, sizeof x_shdr, arg);
1124 if (i_shdr.contents)
1125 (*process) (i_shdr.contents, i_shdr.sh_size, arg);
1128 return TRUE;
1131 long
1132 elf_slurp_symbol_table (bfd *abfd, asymbol **symptrs, bfd_boolean dynamic)
1134 Elf_Internal_Shdr *hdr;
1135 Elf_Internal_Shdr *verhdr;
1136 unsigned long symcount; /* Number of external ELF symbols */
1137 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1138 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1139 Elf_Internal_Sym *isym;
1140 Elf_Internal_Sym *isymend;
1141 Elf_Internal_Sym *isymbuf = NULL;
1142 Elf_External_Versym *xver;
1143 Elf_External_Versym *xverbuf = NULL;
1144 const struct elf_backend_data *ebd;
1145 bfd_size_type amt;
1147 /* Read each raw ELF symbol, converting from external ELF form to
1148 internal ELF form, and then using the information to create a
1149 canonical bfd symbol table entry.
1151 Note that we allocate the initial bfd canonical symbol buffer
1152 based on a one-to-one mapping of the ELF symbols to canonical
1153 symbols. We actually use all the ELF symbols, so there will be no
1154 space left over at the end. When we have all the symbols, we
1155 build the caller's pointer vector. */
1157 if (! dynamic)
1159 hdr = &elf_tdata (abfd)->symtab_hdr;
1160 verhdr = NULL;
1162 else
1164 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1165 if (elf_dynversym (abfd) == 0)
1166 verhdr = NULL;
1167 else
1168 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1169 if ((elf_tdata (abfd)->dynverdef_section != 0
1170 && elf_tdata (abfd)->verdef == NULL)
1171 || (elf_tdata (abfd)->dynverref_section != 0
1172 && elf_tdata (abfd)->verref == NULL))
1174 if (!_bfd_elf_slurp_version_tables (abfd, FALSE))
1175 return -1;
1179 ebd = get_elf_backend_data (abfd);
1180 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1181 if (symcount == 0)
1182 sym = symbase = NULL;
1183 else
1185 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1186 NULL, NULL, NULL);
1187 if (isymbuf == NULL)
1188 return -1;
1190 amt = symcount;
1191 amt *= sizeof (elf_symbol_type);
1192 symbase = bfd_zalloc (abfd, amt);
1193 if (symbase == (elf_symbol_type *) NULL)
1194 goto error_return;
1196 /* Read the raw ELF version symbol information. */
1197 if (verhdr != NULL
1198 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1200 (*_bfd_error_handler)
1201 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1202 abfd->filename,
1203 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1204 symcount);
1206 /* Slurp in the symbols without the version information,
1207 since that is more helpful than just quitting. */
1208 verhdr = NULL;
1211 if (verhdr != NULL)
1213 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1214 goto error_return;
1216 xverbuf = bfd_malloc (verhdr->sh_size);
1217 if (xverbuf == NULL && verhdr->sh_size != 0)
1218 goto error_return;
1220 if (bfd_bread (xverbuf, verhdr->sh_size, abfd) != verhdr->sh_size)
1221 goto error_return;
1224 /* Skip first symbol, which is a null dummy. */
1225 xver = xverbuf;
1226 if (xver != NULL)
1227 ++xver;
1228 isymend = isymbuf + symcount;
1229 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1231 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1232 sym->symbol.the_bfd = abfd;
1234 sym->symbol.name = bfd_elf_sym_name (abfd, hdr, isym, NULL);
1236 sym->symbol.value = isym->st_value;
1238 if (isym->st_shndx == SHN_UNDEF)
1240 sym->symbol.section = bfd_und_section_ptr;
1242 else if (isym->st_shndx == SHN_ABS)
1244 sym->symbol.section = bfd_abs_section_ptr;
1246 else if (isym->st_shndx == SHN_COMMON)
1248 sym->symbol.section = bfd_com_section_ptr;
1249 /* Elf puts the alignment into the `value' field, and
1250 the size into the `size' field. BFD wants to see the
1251 size in the value field, and doesn't care (at the
1252 moment) about the alignment. */
1253 sym->symbol.value = isym->st_size;
1255 else
1257 sym->symbol.section
1258 = bfd_section_from_elf_index (abfd, isym->st_shndx);
1259 if (sym->symbol.section == NULL)
1261 /* This symbol is in a section for which we did not
1262 create a BFD section. Just use bfd_abs_section,
1263 although it is wrong. FIXME. */
1264 sym->symbol.section = bfd_abs_section_ptr;
1268 /* If this is a relocatable file, then the symbol value is
1269 already section relative. */
1270 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1271 sym->symbol.value -= sym->symbol.section->vma;
1273 switch (ELF_ST_BIND (isym->st_info))
1275 case STB_LOCAL:
1276 sym->symbol.flags |= BSF_LOCAL;
1277 break;
1278 case STB_GLOBAL:
1279 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1280 sym->symbol.flags |= BSF_GLOBAL;
1281 break;
1282 case STB_WEAK:
1283 sym->symbol.flags |= BSF_WEAK;
1284 break;
1287 switch (ELF_ST_TYPE (isym->st_info))
1289 case STT_SECTION:
1290 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1291 break;
1292 case STT_FILE:
1293 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1294 break;
1295 case STT_FUNC:
1296 sym->symbol.flags |= BSF_FUNCTION;
1297 break;
1298 case STT_COMMON:
1299 /* FIXME: Do we have to put the size field into the value field
1300 as we do with symbols in SHN_COMMON sections (see above) ? */
1301 /* Fall through. */
1302 case STT_OBJECT:
1303 sym->symbol.flags |= BSF_OBJECT;
1304 break;
1305 case STT_TLS:
1306 sym->symbol.flags |= BSF_THREAD_LOCAL;
1307 break;
1308 case STT_RELC:
1309 sym->symbol.flags |= BSF_RELC;
1310 break;
1311 case STT_SRELC:
1312 sym->symbol.flags |= BSF_SRELC;
1313 break;
1316 if (dynamic)
1317 sym->symbol.flags |= BSF_DYNAMIC;
1319 if (xver != NULL)
1321 Elf_Internal_Versym iversym;
1323 _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1324 sym->version = iversym.vs_vers;
1325 xver++;
1328 /* Do some backend-specific processing on this symbol. */
1329 if (ebd->elf_backend_symbol_processing)
1330 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1334 /* Do some backend-specific processing on this symbol table. */
1335 if (ebd->elf_backend_symbol_table_processing)
1336 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1338 /* We rely on the zalloc to clear out the final symbol entry. */
1340 symcount = sym - symbase;
1342 /* Fill in the user's symbol pointer vector if needed. */
1343 if (symptrs)
1345 long l = symcount;
1347 sym = symbase;
1348 while (l-- > 0)
1350 *symptrs++ = &sym->symbol;
1351 sym++;
1353 *symptrs = 0; /* Final null pointer */
1356 if (xverbuf != NULL)
1357 free (xverbuf);
1358 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1359 free (isymbuf);
1360 return symcount;
1362 error_return:
1363 if (xverbuf != NULL)
1364 free (xverbuf);
1365 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1366 free (isymbuf);
1367 return -1;
1370 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1371 them. */
1373 static bfd_boolean
1374 elf_slurp_reloc_table_from_section (bfd *abfd,
1375 asection *asect,
1376 Elf_Internal_Shdr *rel_hdr,
1377 bfd_size_type reloc_count,
1378 arelent *relents,
1379 asymbol **symbols,
1380 bfd_boolean dynamic)
1382 const struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1383 void *allocated = NULL;
1384 bfd_byte *native_relocs;
1385 arelent *relent;
1386 unsigned int i;
1387 int entsize;
1388 unsigned int symcount;
1390 allocated = bfd_malloc (rel_hdr->sh_size);
1391 if (allocated == NULL)
1392 goto error_return;
1394 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1395 || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1396 != rel_hdr->sh_size))
1397 goto error_return;
1399 native_relocs = allocated;
1401 entsize = rel_hdr->sh_entsize;
1402 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1403 || entsize == sizeof (Elf_External_Rela));
1405 if (dynamic)
1406 symcount = bfd_get_dynamic_symcount (abfd);
1407 else
1408 symcount = bfd_get_symcount (abfd);
1410 for (i = 0, relent = relents;
1411 i < reloc_count;
1412 i++, relent++, native_relocs += entsize)
1414 Elf_Internal_Rela rela;
1416 if (entsize == sizeof (Elf_External_Rela))
1417 elf_swap_reloca_in (abfd, native_relocs, &rela);
1418 else
1419 elf_swap_reloc_in (abfd, native_relocs, &rela);
1421 /* The address of an ELF reloc is section relative for an object
1422 file, and absolute for an executable file or shared library.
1423 The address of a normal BFD reloc is always section relative,
1424 and the address of a dynamic reloc is absolute.. */
1425 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1426 relent->address = rela.r_offset;
1427 else
1428 relent->address = rela.r_offset - asect->vma;
1430 if (ELF_R_SYM (rela.r_info) == 0)
1431 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1432 else if (ELF_R_SYM (rela.r_info) > symcount)
1434 (*_bfd_error_handler)
1435 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1436 abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1437 relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1439 else
1441 asymbol **ps;
1443 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1445 relent->sym_ptr_ptr = ps;
1448 relent->addend = rela.r_addend;
1450 if ((entsize == sizeof (Elf_External_Rela)
1451 && ebd->elf_info_to_howto != NULL)
1452 || ebd->elf_info_to_howto_rel == NULL)
1453 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1454 else
1455 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1458 if (allocated != NULL)
1459 free (allocated);
1461 return TRUE;
1463 error_return:
1464 if (allocated != NULL)
1465 free (allocated);
1466 return FALSE;
1469 /* Read in and swap the external relocs. */
1471 bfd_boolean
1472 elf_slurp_reloc_table (bfd *abfd,
1473 asection *asect,
1474 asymbol **symbols,
1475 bfd_boolean dynamic)
1477 struct bfd_elf_section_data * const d = elf_section_data (asect);
1478 Elf_Internal_Shdr *rel_hdr;
1479 Elf_Internal_Shdr *rel_hdr2;
1480 bfd_size_type reloc_count;
1481 bfd_size_type reloc_count2;
1482 arelent *relents;
1483 bfd_size_type amt;
1485 if (asect->relocation != NULL)
1486 return TRUE;
1488 if (! dynamic)
1490 if ((asect->flags & SEC_RELOC) == 0
1491 || asect->reloc_count == 0)
1492 return TRUE;
1494 rel_hdr = &d->rel_hdr;
1495 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1496 rel_hdr2 = d->rel_hdr2;
1497 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1499 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1500 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1501 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1504 else
1506 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1507 case because relocations against this section may use the
1508 dynamic symbol table, and in that case bfd_section_from_shdr
1509 in elf.c does not update the RELOC_COUNT. */
1510 if (asect->size == 0)
1511 return TRUE;
1513 rel_hdr = &d->this_hdr;
1514 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1515 rel_hdr2 = NULL;
1516 reloc_count2 = 0;
1519 amt = (reloc_count + reloc_count2) * sizeof (arelent);
1520 relents = bfd_alloc (abfd, amt);
1521 if (relents == NULL)
1522 return FALSE;
1524 if (!elf_slurp_reloc_table_from_section (abfd, asect,
1525 rel_hdr, reloc_count,
1526 relents,
1527 symbols, dynamic))
1528 return FALSE;
1530 if (rel_hdr2
1531 && !elf_slurp_reloc_table_from_section (abfd, asect,
1532 rel_hdr2, reloc_count2,
1533 relents + reloc_count,
1534 symbols, dynamic))
1535 return FALSE;
1537 asect->relocation = relents;
1538 return TRUE;
1541 #if DEBUG & 2
1542 static void
1543 elf_debug_section (int num, Elf_Internal_Shdr *hdr)
1545 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1546 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1547 (long) hdr);
1548 fprintf (stderr,
1549 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1550 (long) hdr->sh_name,
1551 (long) hdr->sh_type,
1552 (long) hdr->sh_flags);
1553 fprintf (stderr,
1554 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1555 (long) hdr->sh_addr,
1556 (long) hdr->sh_offset,
1557 (long) hdr->sh_size);
1558 fprintf (stderr,
1559 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1560 (long) hdr->sh_link,
1561 (long) hdr->sh_info,
1562 (long) hdr->sh_addralign);
1563 fprintf (stderr, "sh_entsize = %ld\n",
1564 (long) hdr->sh_entsize);
1565 fflush (stderr);
1567 #endif
1569 #if DEBUG & 1
1570 static void
1571 elf_debug_file (Elf_Internal_Ehdr *ehdrp)
1573 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1574 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1575 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1576 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1577 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1578 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1579 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1581 #endif
1583 /* Create a new BFD as if by bfd_openr. Rather than opening a file,
1584 reconstruct an ELF file by reading the segments out of remote memory
1585 based on the ELF file header at EHDR_VMA and the ELF program headers it
1586 points to. If not null, *LOADBASEP is filled in with the difference
1587 between the VMAs from which the segments were read, and the VMAs the
1588 file headers (and hence BFD's idea of each section's VMA) put them at.
1590 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
1591 remote memory at target address VMA into the local buffer at MYADDR; it
1592 should return zero on success or an `errno' code on failure. TEMPL must
1593 be a BFD for a target with the word size and byte order found in the
1594 remote memory. */
1596 bfd *
1597 NAME(_bfd_elf,bfd_from_remote_memory)
1598 (bfd *templ,
1599 bfd_vma ehdr_vma,
1600 bfd_vma *loadbasep,
1601 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
1603 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
1604 Elf_Internal_Ehdr i_ehdr; /* Elf file header, internal form */
1605 Elf_External_Phdr *x_phdrs;
1606 Elf_Internal_Phdr *i_phdrs, *last_phdr;
1607 bfd *nbfd;
1608 struct bfd_in_memory *bim;
1609 int contents_size;
1610 bfd_byte *contents;
1611 int err;
1612 unsigned int i;
1613 bfd_vma loadbase;
1614 bfd_boolean loadbase_set;
1616 /* Read in the ELF header in external format. */
1617 err = target_read_memory (ehdr_vma, (bfd_byte *) &x_ehdr, sizeof x_ehdr);
1618 if (err)
1620 bfd_set_error (bfd_error_system_call);
1621 errno = err;
1622 return NULL;
1625 /* Now check to see if we have a valid ELF file, and one that BFD can
1626 make use of. The magic number must match, the address size ('class')
1627 and byte-swapping must match our XVEC entry. */
1629 if (! elf_file_p (&x_ehdr)
1630 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
1631 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
1633 bfd_set_error (bfd_error_wrong_format);
1634 return NULL;
1637 /* Check that file's byte order matches xvec's */
1638 switch (x_ehdr.e_ident[EI_DATA])
1640 case ELFDATA2MSB: /* Big-endian */
1641 if (! bfd_header_big_endian (templ))
1643 bfd_set_error (bfd_error_wrong_format);
1644 return NULL;
1646 break;
1647 case ELFDATA2LSB: /* Little-endian */
1648 if (! bfd_header_little_endian (templ))
1650 bfd_set_error (bfd_error_wrong_format);
1651 return NULL;
1653 break;
1654 case ELFDATANONE: /* No data encoding specified */
1655 default: /* Unknown data encoding specified */
1656 bfd_set_error (bfd_error_wrong_format);
1657 return NULL;
1660 elf_swap_ehdr_in (templ, &x_ehdr, &i_ehdr);
1662 /* The file header tells where to find the program headers.
1663 These are what we use to actually choose what to read. */
1665 if (i_ehdr.e_phentsize != sizeof (Elf_External_Phdr) || i_ehdr.e_phnum == 0)
1667 bfd_set_error (bfd_error_wrong_format);
1668 return NULL;
1671 x_phdrs = bfd_malloc (i_ehdr.e_phnum * (sizeof *x_phdrs + sizeof *i_phdrs));
1672 if (x_phdrs == NULL)
1674 bfd_set_error (bfd_error_no_memory);
1675 return NULL;
1677 err = target_read_memory (ehdr_vma + i_ehdr.e_phoff, (bfd_byte *) x_phdrs,
1678 i_ehdr.e_phnum * sizeof x_phdrs[0]);
1679 if (err)
1681 free (x_phdrs);
1682 bfd_set_error (bfd_error_system_call);
1683 errno = err;
1684 return NULL;
1686 i_phdrs = (Elf_Internal_Phdr *) &x_phdrs[i_ehdr.e_phnum];
1688 contents_size = 0;
1689 last_phdr = NULL;
1690 loadbase = ehdr_vma;
1691 loadbase_set = FALSE;
1692 for (i = 0; i < i_ehdr.e_phnum; ++i)
1694 elf_swap_phdr_in (templ, &x_phdrs[i], &i_phdrs[i]);
1695 if (i_phdrs[i].p_type == PT_LOAD)
1697 bfd_vma segment_end;
1698 segment_end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1699 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1700 if (segment_end > (bfd_vma) contents_size)
1701 contents_size = segment_end;
1703 /* LOADADDR is the `Base address' from the gELF specification:
1704 `lowest p_vaddr value for a PT_LOAD segment' is P_VADDR from the
1705 first PT_LOAD as PT_LOADs are ordered by P_VADDR. */
1706 if (!loadbase_set && (i_phdrs[i].p_offset & -i_phdrs[i].p_align) == 0)
1708 loadbase = ehdr_vma - (i_phdrs[i].p_vaddr & -i_phdrs[i].p_align);
1709 loadbase_set = TRUE;
1712 last_phdr = &i_phdrs[i];
1715 if (last_phdr == NULL)
1717 /* There were no PT_LOAD segments, so we don't have anything to read. */
1718 free (x_phdrs);
1719 bfd_set_error (bfd_error_wrong_format);
1720 return NULL;
1723 /* Trim the last segment so we don't bother with zeros in the last page
1724 that are off the end of the file. However, if the extra bit in that
1725 page includes the section headers, keep them. */
1726 if ((bfd_vma) contents_size > last_phdr->p_offset + last_phdr->p_filesz
1727 && (bfd_vma) contents_size >= (i_ehdr.e_shoff
1728 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1730 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1731 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1732 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1733 contents_size = i_ehdr.e_shoff + i_ehdr.e_shnum * i_ehdr.e_shentsize;
1735 else
1736 contents_size = last_phdr->p_offset + last_phdr->p_filesz;
1738 /* Now we know the size of the whole image we want read in. */
1739 contents = bfd_zmalloc (contents_size);
1740 if (contents == NULL)
1742 free (x_phdrs);
1743 bfd_set_error (bfd_error_no_memory);
1744 return NULL;
1747 for (i = 0; i < i_ehdr.e_phnum; ++i)
1748 if (i_phdrs[i].p_type == PT_LOAD)
1750 bfd_vma start = i_phdrs[i].p_offset & -i_phdrs[i].p_align;
1751 bfd_vma end = (i_phdrs[i].p_offset + i_phdrs[i].p_filesz
1752 + i_phdrs[i].p_align - 1) & -i_phdrs[i].p_align;
1753 if (end > (bfd_vma) contents_size)
1754 end = contents_size;
1755 err = target_read_memory ((loadbase + i_phdrs[i].p_vaddr)
1756 & -i_phdrs[i].p_align,
1757 contents + start, end - start);
1758 if (err)
1760 free (x_phdrs);
1761 free (contents);
1762 bfd_set_error (bfd_error_system_call);
1763 errno = err;
1764 return NULL;
1767 free (x_phdrs);
1769 /* If the segments visible in memory didn't include the section headers,
1770 then clear them from the file header. */
1771 if ((bfd_vma) contents_size < (i_ehdr.e_shoff
1772 + i_ehdr.e_shnum * i_ehdr.e_shentsize))
1774 memset (&x_ehdr.e_shoff, 0, sizeof x_ehdr.e_shoff);
1775 memset (&x_ehdr.e_shnum, 0, sizeof x_ehdr.e_shnum);
1776 memset (&x_ehdr.e_shstrndx, 0, sizeof x_ehdr.e_shstrndx);
1779 /* This will normally have been in the first PT_LOAD segment. But it
1780 conceivably could be missing, and we might have just changed it. */
1781 memcpy (contents, &x_ehdr, sizeof x_ehdr);
1783 /* Now we have a memory image of the ELF file contents. Make a BFD. */
1784 bim = bfd_malloc (sizeof (struct bfd_in_memory));
1785 if (bim == NULL)
1787 free (contents);
1788 bfd_set_error (bfd_error_no_memory);
1789 return NULL;
1791 nbfd = _bfd_new_bfd ();
1792 if (nbfd == NULL)
1794 free (bim);
1795 free (contents);
1796 bfd_set_error (bfd_error_no_memory);
1797 return NULL;
1799 nbfd->filename = "<in-memory>";
1800 nbfd->xvec = templ->xvec;
1801 bim->size = contents_size;
1802 bim->buffer = contents;
1803 nbfd->iostream = bim;
1804 nbfd->flags = BFD_IN_MEMORY;
1805 nbfd->direction = read_direction;
1806 nbfd->mtime = time (NULL);
1807 nbfd->mtime_set = TRUE;
1809 if (loadbasep)
1810 *loadbasep = loadbase;
1811 return nbfd;
1814 #include "elfcore.h"
1816 /* Size-dependent data and functions. */
1817 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1818 sizeof (Elf_External_Ehdr),
1819 sizeof (Elf_External_Phdr),
1820 sizeof (Elf_External_Shdr),
1821 sizeof (Elf_External_Rel),
1822 sizeof (Elf_External_Rela),
1823 sizeof (Elf_External_Sym),
1824 sizeof (Elf_External_Dyn),
1825 sizeof (Elf_External_Note),
1828 ARCH_SIZE, LOG_FILE_ALIGN,
1829 ELFCLASS, EV_CURRENT,
1830 elf_write_out_phdrs,
1831 elf_write_shdrs_and_ehdr,
1832 elf_checksum_contents,
1833 elf_write_relocs,
1834 elf_swap_symbol_in,
1835 elf_swap_symbol_out,
1836 elf_slurp_reloc_table,
1837 elf_slurp_symbol_table,
1838 elf_swap_dyn_in,
1839 elf_swap_dyn_out,
1840 elf_swap_reloc_in,
1841 elf_swap_reloc_out,
1842 elf_swap_reloca_in,
1843 elf_swap_reloca_out