1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003 Free Software Foundation, Inc.
5 Written by Fred Fish @ Cygnus Support, from information published
6 in "UNIX System V Release 4, Programmers Guide: ANSI C and
7 Programming Support Tools". Sufficient support for gdb.
9 Rewritten by Mark Eichin @ Cygnus Support, from information
10 published in "System V Application Binary Interface", chapters 4
11 and 5, as well as the various "Processor Supplement" documents
12 derived from it. Added support for assembler and other object file
13 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
14 Meissner (Open Software Foundation), and Peter Hoogenboom (University
15 of Utah) to finish and extend this.
17 This file is part of BFD, the Binary File Descriptor library.
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License, or
22 (at your option) any later version.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 GNU General Public License for more details.
29 You should have received a copy of the GNU General Public License
30 along with this program; if not, write to the Free Software
31 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 /* Problems and other issues to resolve.
35 (1) BFD expects there to be some fixed number of "sections" in
36 the object file. I.E. there is a "section_count" variable in the
37 bfd structure which contains the number of sections. However, ELF
38 supports multiple "views" of a file. In particular, with current
39 implementations, executable files typically have two tables, a
40 program header table and a section header table, both of which
41 partition the executable.
43 In ELF-speak, the "linking view" of the file uses the section header
44 table to access "sections" within the file, and the "execution view"
45 uses the program header table to access "segments" within the file.
46 "Segments" typically may contain all the data from one or more
49 Note that the section header table is optional in ELF executables,
50 but it is this information that is most useful to gdb. If the
51 section header table is missing, then gdb should probably try
52 to make do with the program header table. (FIXME)
54 (2) The code in this file is compiled twice, once in 32-bit mode and
55 once in 64-bit mode. More of it should be made size-independent
58 (3) ELF section symbols are handled rather sloppily now. This should
59 be cleaned up, and ELF section symbols reconciled with BFD section
62 (4) We need a published spec for 64-bit ELF. We've got some stuff here
63 that we're using for SPARC V9 64-bit chips, but don't assume that
69 #include "libiberty.h"
74 /* Renaming structures, typedefs, macros and functions to be size-specific. */
75 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
76 #define Elf_External_Sym NAME(Elf,External_Sym)
77 #define Elf_External_Shdr NAME(Elf,External_Shdr)
78 #define Elf_External_Phdr NAME(Elf,External_Phdr)
79 #define Elf_External_Rel NAME(Elf,External_Rel)
80 #define Elf_External_Rela NAME(Elf,External_Rela)
81 #define Elf_External_Dyn NAME(Elf,External_Dyn)
83 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
84 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
85 #define elf_core_file_matches_executable_p \
86 NAME(bfd_elf,core_file_matches_executable_p)
87 #define elf_object_p NAME(bfd_elf,object_p)
88 #define elf_core_file_p NAME(bfd_elf,core_file_p)
89 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
90 #define elf_get_dynamic_symtab_upper_bound \
91 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
92 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
93 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
94 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
95 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
96 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
97 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
98 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
99 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
100 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
101 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
102 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
103 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
104 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
105 #define elf_get_symtab NAME(bfd_elf,get_symtab)
106 #define elf_canonicalize_dynamic_symtab \
107 NAME(bfd_elf,canonicalize_dynamic_symtab)
108 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
109 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
110 #define elf_get_lineno NAME(bfd_elf,get_lineno)
111 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
112 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
113 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
114 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
115 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
116 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
117 #define elf_find_section NAME(bfd_elf,find_section)
118 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
119 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
120 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
121 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
122 #define elf_write_relocs NAME(bfd_elf,write_relocs)
123 #define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
124 #define elf_bfd_discard_info NAME(bfd_elf,discard_info)
125 #define elf_reloc_symbol_deleted_p NAME(_bfd_elf,reloc_symbol_deleted_p)
126 #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
127 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
128 #define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
129 #define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
130 #define elf_gc_sections NAME(_bfd_elf,gc_sections)
131 #define elf_gc_common_finalize_got_offsets \
132 NAME(_bfd_elf,gc_common_finalize_got_offsets)
133 #define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
134 #define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
135 #define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
136 #define elf_link_record_local_dynamic_symbol \
137 NAME(_bfd_elf,link_record_local_dynamic_symbol)
140 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
141 #define ELF_R_SYM(X) ELF64_R_SYM(X)
142 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
143 #define ELFCLASS ELFCLASS64
145 #define LOG_FILE_ALIGN 3
148 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
149 #define ELF_R_SYM(X) ELF32_R_SYM(X)
150 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
151 #define ELFCLASS ELFCLASS32
153 #define LOG_FILE_ALIGN 2
156 /* Static functions */
158 static void elf_swap_ehdr_in
159 PARAMS ((bfd *, const Elf_External_Ehdr *, Elf_Internal_Ehdr *));
160 static void elf_swap_ehdr_out
161 PARAMS ((bfd *, const Elf_Internal_Ehdr *, Elf_External_Ehdr *));
162 static void elf_swap_shdr_in
163 PARAMS ((bfd *, const Elf_External_Shdr *, Elf_Internal_Shdr *));
164 static void elf_swap_shdr_out
165 PARAMS ((bfd *, const Elf_Internal_Shdr *, Elf_External_Shdr *));
167 #define elf_stringtab_init _bfd_elf_stringtab_init
169 #define section_from_elf_index bfd_section_from_elf_index
171 static bfd_boolean elf_slurp_reloc_table_from_section
172 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, bfd_size_type,
173 arelent *, asymbol **, bfd_boolean));
175 static bfd_boolean elf_file_p PARAMS ((Elf_External_Ehdr *));
178 static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
179 static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
180 static char *elf_symbol_flags PARAMS ((flagword));
183 /* Structure swapping routines */
185 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
186 can be handled by explicitly specifying 32 bits or "the long type". */
188 #define H_PUT_WORD H_PUT_64
189 #define H_PUT_SIGNED_WORD H_PUT_S64
190 #define H_GET_WORD H_GET_64
191 #define H_GET_SIGNED_WORD H_GET_S64
194 #define H_PUT_WORD H_PUT_32
195 #define H_PUT_SIGNED_WORD H_PUT_S32
196 #define H_GET_WORD H_GET_32
197 #define H_GET_SIGNED_WORD H_GET_S32
200 /* Translate an ELF symbol in external format into an ELF symbol in internal
204 elf_swap_symbol_in (abfd, psrc, pshn, dst)
208 Elf_Internal_Sym *dst;
210 const Elf_External_Sym *src = (const Elf_External_Sym *) psrc;
211 const Elf_External_Sym_Shndx *shndx = (const Elf_External_Sym_Shndx *) pshn;
212 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
214 dst->st_name = H_GET_32 (abfd, src->st_name);
216 dst->st_value = H_GET_SIGNED_WORD (abfd, src->st_value);
218 dst->st_value = H_GET_WORD (abfd, src->st_value);
219 dst->st_size = H_GET_WORD (abfd, src->st_size);
220 dst->st_info = H_GET_8 (abfd, src->st_info);
221 dst->st_other = H_GET_8 (abfd, src->st_other);
222 dst->st_shndx = H_GET_16 (abfd, src->st_shndx);
223 if (dst->st_shndx == SHN_XINDEX)
227 dst->st_shndx = H_GET_32 (abfd, shndx->est_shndx);
231 /* Translate an ELF symbol in internal format into an ELF symbol in external
235 elf_swap_symbol_out (abfd, src, cdst, shndx)
237 const Elf_Internal_Sym *src;
242 Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
243 H_PUT_32 (abfd, src->st_name, dst->st_name);
244 H_PUT_WORD (abfd, src->st_value, dst->st_value);
245 H_PUT_WORD (abfd, src->st_size, dst->st_size);
246 H_PUT_8 (abfd, src->st_info, dst->st_info);
247 H_PUT_8 (abfd, src->st_other, dst->st_other);
249 if (tmp > SHN_HIRESERVE)
253 H_PUT_32 (abfd, tmp, shndx);
256 H_PUT_16 (abfd, tmp, dst->st_shndx);
259 /* Translate an ELF file header in external format into an ELF file header in
263 elf_swap_ehdr_in (abfd, src, dst)
265 const Elf_External_Ehdr *src;
266 Elf_Internal_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 dst->e_type = H_GET_16 (abfd, src->e_type);
271 dst->e_machine = H_GET_16 (abfd, src->e_machine);
272 dst->e_version = H_GET_32 (abfd, src->e_version);
274 dst->e_entry = H_GET_SIGNED_WORD (abfd, src->e_entry);
276 dst->e_entry = H_GET_WORD (abfd, src->e_entry);
277 dst->e_phoff = H_GET_WORD (abfd, src->e_phoff);
278 dst->e_shoff = H_GET_WORD (abfd, src->e_shoff);
279 dst->e_flags = H_GET_32 (abfd, src->e_flags);
280 dst->e_ehsize = H_GET_16 (abfd, src->e_ehsize);
281 dst->e_phentsize = H_GET_16 (abfd, src->e_phentsize);
282 dst->e_phnum = H_GET_16 (abfd, src->e_phnum);
283 dst->e_shentsize = H_GET_16 (abfd, src->e_shentsize);
284 dst->e_shnum = H_GET_16 (abfd, src->e_shnum);
285 dst->e_shstrndx = H_GET_16 (abfd, src->e_shstrndx);
288 /* Translate an ELF file header in internal format into an ELF file header in
292 elf_swap_ehdr_out (abfd, src, dst)
294 const Elf_Internal_Ehdr *src;
295 Elf_External_Ehdr *dst;
298 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
299 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
300 /* note that all elements of dst are *arrays of unsigned char* already... */
301 H_PUT_16 (abfd, src->e_type, dst->e_type);
302 H_PUT_16 (abfd, src->e_machine, dst->e_machine);
303 H_PUT_32 (abfd, src->e_version, dst->e_version);
305 H_PUT_SIGNED_WORD (abfd, src->e_entry, dst->e_entry);
307 H_PUT_WORD (abfd, src->e_entry, dst->e_entry);
308 H_PUT_WORD (abfd, src->e_phoff, dst->e_phoff);
309 H_PUT_WORD (abfd, src->e_shoff, dst->e_shoff);
310 H_PUT_32 (abfd, src->e_flags, dst->e_flags);
311 H_PUT_16 (abfd, src->e_ehsize, dst->e_ehsize);
312 H_PUT_16 (abfd, src->e_phentsize, dst->e_phentsize);
313 H_PUT_16 (abfd, src->e_phnum, dst->e_phnum);
314 H_PUT_16 (abfd, src->e_shentsize, dst->e_shentsize);
316 if (tmp >= SHN_LORESERVE)
318 H_PUT_16 (abfd, tmp, dst->e_shnum);
319 tmp = src->e_shstrndx;
320 if (tmp >= SHN_LORESERVE)
322 H_PUT_16 (abfd, tmp, dst->e_shstrndx);
325 /* Translate an ELF section header table entry in external format into an
326 ELF section header table entry in internal format. */
329 elf_swap_shdr_in (abfd, src, dst)
331 const Elf_External_Shdr *src;
332 Elf_Internal_Shdr *dst;
334 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
336 dst->sh_name = H_GET_32 (abfd, src->sh_name);
337 dst->sh_type = H_GET_32 (abfd, src->sh_type);
338 dst->sh_flags = H_GET_WORD (abfd, src->sh_flags);
340 dst->sh_addr = H_GET_SIGNED_WORD (abfd, src->sh_addr);
342 dst->sh_addr = H_GET_WORD (abfd, src->sh_addr);
343 dst->sh_offset = H_GET_WORD (abfd, src->sh_offset);
344 dst->sh_size = H_GET_WORD (abfd, src->sh_size);
345 dst->sh_link = H_GET_32 (abfd, src->sh_link);
346 dst->sh_info = H_GET_32 (abfd, src->sh_info);
347 dst->sh_addralign = H_GET_WORD (abfd, src->sh_addralign);
348 dst->sh_entsize = H_GET_WORD (abfd, src->sh_entsize);
349 dst->bfd_section = NULL;
350 dst->contents = NULL;
353 /* Translate an ELF section header table entry in internal format into an
354 ELF section header table entry in external format. */
357 elf_swap_shdr_out (abfd, src, dst)
359 const Elf_Internal_Shdr *src;
360 Elf_External_Shdr *dst;
362 /* note that all elements of dst are *arrays of unsigned char* already... */
363 H_PUT_32 (abfd, src->sh_name, dst->sh_name);
364 H_PUT_32 (abfd, src->sh_type, dst->sh_type);
365 H_PUT_WORD (abfd, src->sh_flags, dst->sh_flags);
366 H_PUT_WORD (abfd, src->sh_addr, dst->sh_addr);
367 H_PUT_WORD (abfd, src->sh_offset, dst->sh_offset);
368 H_PUT_WORD (abfd, src->sh_size, dst->sh_size);
369 H_PUT_32 (abfd, src->sh_link, dst->sh_link);
370 H_PUT_32 (abfd, src->sh_info, dst->sh_info);
371 H_PUT_WORD (abfd, src->sh_addralign, dst->sh_addralign);
372 H_PUT_WORD (abfd, src->sh_entsize, dst->sh_entsize);
375 /* Translate an ELF program header table entry in external format into an
376 ELF program header table entry in internal format. */
379 elf_swap_phdr_in (abfd, src, dst)
381 const Elf_External_Phdr *src;
382 Elf_Internal_Phdr *dst;
384 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
386 dst->p_type = H_GET_32 (abfd, src->p_type);
387 dst->p_flags = H_GET_32 (abfd, src->p_flags);
388 dst->p_offset = H_GET_WORD (abfd, src->p_offset);
391 dst->p_vaddr = H_GET_SIGNED_WORD (abfd, src->p_vaddr);
392 dst->p_paddr = H_GET_SIGNED_WORD (abfd, src->p_paddr);
396 dst->p_vaddr = H_GET_WORD (abfd, src->p_vaddr);
397 dst->p_paddr = H_GET_WORD (abfd, src->p_paddr);
399 dst->p_filesz = H_GET_WORD (abfd, src->p_filesz);
400 dst->p_memsz = H_GET_WORD (abfd, src->p_memsz);
401 dst->p_align = H_GET_WORD (abfd, src->p_align);
405 elf_swap_phdr_out (abfd, src, dst)
407 const Elf_Internal_Phdr *src;
408 Elf_External_Phdr *dst;
410 /* note that all elements of dst are *arrays of unsigned char* already... */
411 H_PUT_32 (abfd, src->p_type, dst->p_type);
412 H_PUT_WORD (abfd, src->p_offset, dst->p_offset);
413 H_PUT_WORD (abfd, src->p_vaddr, dst->p_vaddr);
414 H_PUT_WORD (abfd, src->p_paddr, dst->p_paddr);
415 H_PUT_WORD (abfd, src->p_filesz, dst->p_filesz);
416 H_PUT_WORD (abfd, src->p_memsz, dst->p_memsz);
417 H_PUT_32 (abfd, src->p_flags, dst->p_flags);
418 H_PUT_WORD (abfd, src->p_align, dst->p_align);
421 /* Translate an ELF reloc from external format to internal format. */
423 elf_swap_reloc_in (abfd, s, dst)
426 Elf_Internal_Rela *dst;
428 const Elf_External_Rel *src = (const Elf_External_Rel *) s;
429 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
430 dst->r_info = H_GET_WORD (abfd, src->r_info);
435 elf_swap_reloca_in (abfd, s, dst)
438 Elf_Internal_Rela *dst;
440 const Elf_External_Rela *src = (const Elf_External_Rela *) s;
441 dst->r_offset = H_GET_WORD (abfd, src->r_offset);
442 dst->r_info = H_GET_WORD (abfd, src->r_info);
443 dst->r_addend = H_GET_SIGNED_WORD (abfd, src->r_addend);
446 /* Translate an ELF reloc from internal format to external format. */
448 elf_swap_reloc_out (abfd, src, d)
450 const Elf_Internal_Rela *src;
453 Elf_External_Rel *dst = (Elf_External_Rel *) d;
454 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
455 H_PUT_WORD (abfd, src->r_info, dst->r_info);
459 elf_swap_reloca_out (abfd, src, d)
461 const Elf_Internal_Rela *src;
464 Elf_External_Rela *dst = (Elf_External_Rela *) d;
465 H_PUT_WORD (abfd, src->r_offset, dst->r_offset);
466 H_PUT_WORD (abfd, src->r_info, dst->r_info);
467 H_PUT_SIGNED_WORD (abfd, src->r_addend, dst->r_addend);
471 elf_swap_dyn_in (abfd, p, dst)
474 Elf_Internal_Dyn *dst;
476 const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
478 dst->d_tag = H_GET_WORD (abfd, src->d_tag);
479 dst->d_un.d_val = H_GET_WORD (abfd, src->d_un.d_val);
483 elf_swap_dyn_out (abfd, src, p)
485 const Elf_Internal_Dyn *src;
488 Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
490 H_PUT_WORD (abfd, src->d_tag, dst->d_tag);
491 H_PUT_WORD (abfd, src->d_un.d_val, dst->d_un.d_val);
494 /* ELF .o/exec file reading */
496 /* Begin processing a given object.
498 First we validate the file by reading in the ELF header and checking
501 static INLINE bfd_boolean
503 Elf_External_Ehdr *x_ehdrp;
505 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
506 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
507 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
508 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
511 /* Check to see if the file associated with ABFD matches the target vector
514 Note that we may be called several times with the same ABFD, but different
515 target vectors, most of which will not match. We have to avoid leaving
516 any side effects in ABFD, or any data it points to (like tdata), if the
517 file does not match the target vector. */
523 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
524 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
525 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
526 Elf_Internal_Shdr i_shdr;
527 Elf_Internal_Shdr *i_shdrp; /* Section header table, internal form */
528 unsigned int shindex;
529 char *shstrtab; /* Internal copy of section header stringtab */
530 struct elf_backend_data *ebd;
531 struct bfd_preserve preserve;
535 preserve.marker = NULL;
537 /* Read in the ELF header in external format. */
539 if (bfd_bread ((PTR) & x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
542 if (bfd_get_error () != bfd_error_system_call)
543 goto got_wrong_format_error;
548 /* Now check to see if we have a valid ELF file, and one that BFD can
549 make use of. The magic number must match, the address size ('class')
550 and byte-swapping must match our XVEC entry, and it must have a
551 section header table (FIXME: See comments re sections at top of this
554 if (! elf_file_p (&x_ehdr)
555 || x_ehdr.e_ident[EI_VERSION] != EV_CURRENT
556 || x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
557 goto got_wrong_format_error;
559 /* Check that file's byte order matches xvec's */
560 switch (x_ehdr.e_ident[EI_DATA])
562 case ELFDATA2MSB: /* Big-endian */
563 if (! bfd_header_big_endian (abfd))
564 goto got_wrong_format_error;
566 case ELFDATA2LSB: /* Little-endian */
567 if (! bfd_header_little_endian (abfd))
568 goto got_wrong_format_error;
570 case ELFDATANONE: /* No data encoding specified */
571 default: /* Unknown data encoding specified */
572 goto got_wrong_format_error;
575 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
576 the tdata pointer in the bfd. */
578 amt = sizeof (struct elf_obj_tdata);
579 preserve.marker = bfd_zalloc (abfd, amt);
580 if (preserve.marker == NULL)
582 if (!bfd_preserve_save (abfd, &preserve))
585 elf_tdata (abfd) = preserve.marker;
587 /* Now that we know the byte order, swap in the rest of the header */
588 i_ehdrp = elf_elfheader (abfd);
589 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
591 elf_debug_file (i_ehdrp);
594 /* Reject ET_CORE (header indicates core file, not object file) */
595 if (i_ehdrp->e_type == ET_CORE)
596 goto got_wrong_format_error;
598 /* If this is a relocatable file and there is no section header
599 table, then we're hosed. */
600 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
601 goto got_wrong_format_error;
603 /* As a simple sanity check, verify that the what BFD thinks is the
604 size of each section header table entry actually matches the size
605 recorded in the file, but only if there are any sections. */
606 if (i_ehdrp->e_shentsize != sizeof (x_shdr) && i_ehdrp->e_shnum != 0)
607 goto got_wrong_format_error;
609 /* Further sanity check. */
610 if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_shnum != 0)
611 goto got_wrong_format_error;
613 ebd = get_elf_backend_data (abfd);
615 /* Check that the ELF e_machine field matches what this particular
616 BFD format expects. */
617 if (ebd->elf_machine_code != i_ehdrp->e_machine
618 && (ebd->elf_machine_alt1 == 0
619 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
620 && (ebd->elf_machine_alt2 == 0
621 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
623 const bfd_target * const *target_ptr;
625 if (ebd->elf_machine_code != EM_NONE)
626 goto got_wrong_format_error;
628 /* This is the generic ELF target. Let it match any ELF target
629 for which we do not have a specific backend. */
630 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
632 struct elf_backend_data *back;
634 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
636 back = (struct elf_backend_data *) (*target_ptr)->backend_data;
637 if (back->elf_machine_code == i_ehdrp->e_machine
638 || (back->elf_machine_alt1 != 0
639 && back->elf_machine_alt1 == i_ehdrp->e_machine)
640 || (back->elf_machine_alt2 != 0
641 && back->elf_machine_alt2 == i_ehdrp->e_machine))
643 /* target_ptr is an ELF backend which matches this
644 object file, so reject the generic ELF target. */
645 goto got_wrong_format_error;
650 if (i_ehdrp->e_type == ET_EXEC)
651 abfd->flags |= EXEC_P;
652 else if (i_ehdrp->e_type == ET_DYN)
653 abfd->flags |= DYNAMIC;
655 if (i_ehdrp->e_phnum > 0)
656 abfd->flags |= D_PAGED;
658 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
660 /* It's OK if this fails for the generic target. */
661 if (ebd->elf_machine_code != EM_NONE)
665 /* Remember the entry point specified in the ELF file header. */
666 bfd_set_start_address (abfd, i_ehdrp->e_entry);
668 if (i_ehdrp->e_shoff != 0)
670 /* Seek to the section header table in the file. */
671 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0)
674 /* Read the first section header at index 0, and convert to internal
676 if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
679 elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
681 /* If the section count is zero, the actual count is in the first
683 if (i_ehdrp->e_shnum == SHN_UNDEF)
684 i_ehdrp->e_shnum = i_shdr.sh_size;
686 /* And similarly for the string table index. */
687 if (i_ehdrp->e_shstrndx == SHN_XINDEX)
688 i_ehdrp->e_shstrndx = i_shdr.sh_link;
691 /* Allocate space for a copy of the section header table in
693 if (i_ehdrp->e_shnum != 0)
695 Elf_Internal_Shdr *shdrp;
696 unsigned int num_sec;
698 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
699 i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
702 num_sec = i_ehdrp->e_shnum;
703 if (num_sec > SHN_LORESERVE)
704 num_sec += SHN_HIRESERVE + 1 - SHN_LORESERVE;
705 elf_numsections (abfd) = num_sec;
706 amt = sizeof (i_shdrp) * num_sec;
707 elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
708 if (!elf_elfsections (abfd))
711 memcpy (i_shdrp, &i_shdr, sizeof (*i_shdrp));
714 if (num_sec > SHN_LORESERVE)
716 for ( ; shindex < SHN_LORESERVE; shindex++)
717 elf_elfsections (abfd)[shindex] = shdrp++;
718 for ( ; shindex < SHN_HIRESERVE + 1; shindex++)
719 elf_elfsections (abfd)[shindex] = i_shdrp;
721 for ( ; shindex < num_sec; shindex++)
722 elf_elfsections (abfd)[shindex] = shdrp++;
724 /* Read in the rest of the section header table and convert it
726 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
728 if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
731 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
733 /* If the section is loaded, but not page aligned, clear
735 if (i_shdrp[shindex].sh_size != 0
736 && (i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
737 && i_shdrp[shindex].sh_type != SHT_NOBITS
738 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
741 abfd->flags &= ~D_PAGED;
745 if (i_ehdrp->e_shstrndx && i_ehdrp->e_shoff)
747 if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
751 /* Read in the program headers. */
752 if (i_ehdrp->e_phnum == 0)
753 elf_tdata (abfd)->phdr = NULL;
756 Elf_Internal_Phdr *i_phdr;
759 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
760 elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
761 if (elf_tdata (abfd)->phdr == NULL)
763 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
765 i_phdr = elf_tdata (abfd)->phdr;
766 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
768 Elf_External_Phdr x_phdr;
770 if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof x_phdr, abfd)
773 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
777 /* Read in the string table containing the names of the sections. We
778 will need the base pointer to this table later. */
779 /* We read this inline now, so that we don't have to go through
780 bfd_section_from_shdr with it (since this particular strtab is
781 used to find all of the ELF section names.) */
783 if (i_ehdrp->e_shstrndx != 0 && i_ehdrp->e_shoff)
785 unsigned int num_sec;
787 shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
791 /* Once all of the section headers have been read and converted, we
792 can start processing them. Note that the first section header is
793 a dummy placeholder entry, so we ignore it. */
794 num_sec = elf_numsections (abfd);
795 for (shindex = 1; shindex < num_sec; shindex++)
797 if (! bfd_section_from_shdr (abfd, shindex))
799 if (shindex == SHN_LORESERVE - 1)
800 shindex += SHN_HIRESERVE + 1 - SHN_LORESERVE;
804 /* Let the backend double check the format and override global
806 if (ebd->elf_backend_object_p)
808 if (! (*ebd->elf_backend_object_p) (abfd))
809 goto got_wrong_format_error;
812 /* If we have created any reloc sections that are associated with
813 debugging sections, mark the reloc sections as debugging as well. */
814 for (s = abfd->sections; s != NULL; s = s->next)
816 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
817 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
818 && elf_section_data (s)->this_hdr.sh_info > 0)
820 unsigned long targ_index;
823 targ_index = elf_section_data (s)->this_hdr.sh_info;
824 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
826 && (targ_sec->flags & SEC_DEBUGGING) != 0)
827 s->flags |= SEC_DEBUGGING;
831 bfd_preserve_finish (abfd, &preserve);
834 got_wrong_format_error:
835 /* There is way too much undoing of half-known state here. The caller,
836 bfd_check_format_matches, really shouldn't iterate on live bfd's to
837 check match/no-match like it does. We have to rely on that a call to
838 bfd_default_set_arch_mach with the previously known mach, undoes what
839 was done by the first bfd_default_set_arch_mach (with mach 0) here.
840 For this to work, only elf-data and the mach may be changed by the
841 target-specific elf_backend_object_p function. Note that saving the
842 whole bfd here and restoring it would be even worse; the first thing
843 you notice is that the cached bfd file position gets out of sync. */
844 bfd_set_error (bfd_error_wrong_format);
847 if (preserve.marker != NULL)
848 bfd_preserve_restore (abfd, &preserve);
852 /* ELF .o/exec file writing */
854 /* Write out the relocs. */
857 elf_write_relocs (abfd, sec, data)
862 bfd_boolean *failedp = (bfd_boolean *) data;
863 Elf_Internal_Shdr *rela_hdr;
865 void (*swap_out) PARAMS ((bfd *, const Elf_Internal_Rela *, bfd_byte *));
872 /* If we have already failed, don't do anything. */
876 if ((sec->flags & SEC_RELOC) == 0)
879 /* The linker backend writes the relocs out itself, and sets the
880 reloc_count field to zero to inhibit writing them here. Also,
881 sometimes the SEC_RELOC flag gets set even when there aren't any
883 if (sec->reloc_count == 0)
886 rela_hdr = &elf_section_data (sec)->rel_hdr;
888 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
889 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
890 if (rela_hdr->contents == NULL)
896 /* Figure out whether the relocations are RELA or REL relocations. */
897 if (rela_hdr->sh_type == SHT_RELA)
899 swap_out = elf_swap_reloca_out;
900 extsize = sizeof (Elf_External_Rela);
902 else if (rela_hdr->sh_type == SHT_REL)
904 swap_out = elf_swap_reloc_out;
905 extsize = sizeof (Elf_External_Rel);
908 /* Every relocation section should be either an SHT_RELA or an
912 /* The address of an ELF reloc is section relative for an object
913 file, and absolute for an executable file or shared library.
914 The address of a BFD reloc is always section relative. */
916 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
917 addr_offset = sec->vma;
919 /* orelocation has the data, reloc_count has the count... */
922 dst_rela = rela_hdr->contents;
924 for (idx = 0; idx < sec->reloc_count; idx++, dst_rela += extsize)
926 Elf_Internal_Rela src_rela;
931 ptr = sec->orelocation[idx];
932 sym = *ptr->sym_ptr_ptr;
935 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
940 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
949 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
950 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
951 && ! _bfd_elf_validate_reloc (abfd, ptr))
957 src_rela.r_offset = ptr->address + addr_offset;
958 src_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
959 src_rela.r_addend = ptr->addend;
960 (*swap_out) (abfd, &src_rela, dst_rela);
964 /* Write out the program headers. */
967 elf_write_out_phdrs (abfd, phdr, count)
969 const Elf_Internal_Phdr *phdr;
974 Elf_External_Phdr extphdr;
975 elf_swap_phdr_out (abfd, phdr, &extphdr);
976 if (bfd_bwrite (&extphdr, (bfd_size_type) sizeof (Elf_External_Phdr),
977 abfd) != sizeof (Elf_External_Phdr))
984 /* Write out the section headers and the ELF file header. */
987 elf_write_shdrs_and_ehdr (abfd)
990 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
991 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
992 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
993 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
997 i_ehdrp = elf_elfheader (abfd);
998 i_shdrp = elf_elfsections (abfd);
1000 /* swap the header before spitting it out... */
1003 elf_debug_file (i_ehdrp);
1005 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
1006 amt = sizeof (x_ehdr);
1007 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
1008 || bfd_bwrite ((PTR) & x_ehdr, amt, abfd) != amt)
1011 /* Some fields in the first section header handle overflow of ehdr
1013 if (i_ehdrp->e_shnum >= SHN_LORESERVE)
1014 i_shdrp[0]->sh_size = i_ehdrp->e_shnum;
1015 if (i_ehdrp->e_shstrndx >= SHN_LORESERVE)
1016 i_shdrp[0]->sh_link = i_ehdrp->e_shstrndx;
1018 /* at this point we've concocted all the ELF sections... */
1019 amt = i_ehdrp->e_shnum;
1020 amt *= sizeof (*x_shdrp);
1021 x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
1025 for (count = 0; count < i_ehdrp->e_shnum; i_shdrp++, count++)
1028 elf_debug_section (count, *i_shdrp);
1030 elf_swap_shdr_out (abfd, *i_shdrp, x_shdrp + count);
1032 if (count == SHN_LORESERVE - 1)
1033 i_shdrp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
1035 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
1036 || bfd_bwrite ((PTR) x_shdrp, amt, abfd) != amt)
1039 /* need to dump the string table too... */
1045 elf_slurp_symbol_table (abfd, symptrs, dynamic)
1047 asymbol **symptrs; /* Buffer for generated bfd symbols */
1048 bfd_boolean dynamic;
1050 Elf_Internal_Shdr *hdr;
1051 Elf_Internal_Shdr *verhdr;
1052 unsigned long symcount; /* Number of external ELF symbols */
1053 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1054 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1055 Elf_Internal_Sym *isym;
1056 Elf_Internal_Sym *isymend;
1057 Elf_Internal_Sym *isymbuf = NULL;
1058 Elf_External_Versym *xver;
1059 Elf_External_Versym *xverbuf = NULL;
1060 struct elf_backend_data *ebd;
1063 /* Read each raw ELF symbol, converting from external ELF form to
1064 internal ELF form, and then using the information to create a
1065 canonical bfd symbol table entry.
1067 Note that we allocate the initial bfd canonical symbol buffer
1068 based on a one-to-one mapping of the ELF symbols to canonical
1069 symbols. We actually use all the ELF symbols, so there will be no
1070 space left over at the end. When we have all the symbols, we
1071 build the caller's pointer vector. */
1075 hdr = &elf_tdata (abfd)->symtab_hdr;
1080 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1081 if (elf_dynversym (abfd) == 0)
1084 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1085 if ((elf_tdata (abfd)->dynverdef_section != 0
1086 && elf_tdata (abfd)->verdef == NULL)
1087 || (elf_tdata (abfd)->dynverref_section != 0
1088 && elf_tdata (abfd)->verref == NULL))
1090 if (! _bfd_elf_slurp_version_tables (abfd))
1095 ebd = get_elf_backend_data (abfd);
1096 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1098 sym = symbase = NULL;
1101 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, symcount, 0,
1103 if (isymbuf == NULL)
1107 amt *= sizeof (elf_symbol_type);
1108 symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
1109 if (symbase == (elf_symbol_type *) NULL)
1112 /* Read the raw ELF version symbol information. */
1114 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1116 (*_bfd_error_handler)
1117 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1119 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1122 /* Slurp in the symbols without the version information,
1123 since that is more helpful than just quitting. */
1129 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1132 xverbuf = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1133 if (xverbuf == NULL && verhdr->sh_size != 0)
1136 if (bfd_bread ((PTR) xverbuf, verhdr->sh_size, abfd)
1141 /* Skip first symbol, which is a null dummy. */
1145 isymend = isymbuf + symcount;
1146 for (isym = isymbuf + 1, sym = symbase; isym < isymend; isym++, sym++)
1148 memcpy (&sym->internal_elf_sym, isym, sizeof (Elf_Internal_Sym));
1149 sym->symbol.the_bfd = abfd;
1151 sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1155 sym->symbol.value = isym->st_value;
1157 if (isym->st_shndx == SHN_UNDEF)
1159 sym->symbol.section = bfd_und_section_ptr;
1161 else if (isym->st_shndx < SHN_LORESERVE
1162 || isym->st_shndx > SHN_HIRESERVE)
1164 sym->symbol.section = section_from_elf_index (abfd,
1166 if (sym->symbol.section == NULL)
1168 /* This symbol is in a section for which we did not
1169 create a BFD section. Just use bfd_abs_section,
1170 although it is wrong. FIXME. */
1171 sym->symbol.section = bfd_abs_section_ptr;
1174 else if (isym->st_shndx == SHN_ABS)
1176 sym->symbol.section = bfd_abs_section_ptr;
1178 else if (isym->st_shndx == SHN_COMMON)
1180 sym->symbol.section = bfd_com_section_ptr;
1181 /* Elf puts the alignment into the `value' field, and
1182 the size into the `size' field. BFD wants to see the
1183 size in the value field, and doesn't care (at the
1184 moment) about the alignment. */
1185 sym->symbol.value = isym->st_size;
1188 sym->symbol.section = bfd_abs_section_ptr;
1190 /* If this is a relocateable file, then the symbol value is
1191 already section relative. */
1192 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1193 sym->symbol.value -= sym->symbol.section->vma;
1195 switch (ELF_ST_BIND (isym->st_info))
1198 sym->symbol.flags |= BSF_LOCAL;
1201 if (isym->st_shndx != SHN_UNDEF && isym->st_shndx != SHN_COMMON)
1202 sym->symbol.flags |= BSF_GLOBAL;
1205 sym->symbol.flags |= BSF_WEAK;
1209 switch (ELF_ST_TYPE (isym->st_info))
1212 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1215 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1218 sym->symbol.flags |= BSF_FUNCTION;
1221 sym->symbol.flags |= BSF_OBJECT;
1226 sym->symbol.flags |= BSF_DYNAMIC;
1230 Elf_Internal_Versym iversym;
1232 _bfd_elf_swap_versym_in (abfd, xver, &iversym);
1233 sym->version = iversym.vs_vers;
1237 /* Do some backend-specific processing on this symbol. */
1238 if (ebd->elf_backend_symbol_processing)
1239 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1243 /* Do some backend-specific processing on this symbol table. */
1244 if (ebd->elf_backend_symbol_table_processing)
1245 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1247 /* We rely on the zalloc to clear out the final symbol entry. */
1249 symcount = sym - symbase;
1251 /* Fill in the user's symbol pointer vector if needed. */
1259 *symptrs++ = &sym->symbol;
1262 *symptrs = 0; /* Final null pointer */
1265 if (xverbuf != NULL)
1267 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1272 if (xverbuf != NULL)
1274 if (isymbuf != NULL && hdr->contents != (unsigned char *) isymbuf)
1279 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1283 elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1284 relents, symbols, dynamic)
1287 Elf_Internal_Shdr *rel_hdr;
1288 bfd_size_type reloc_count;
1291 bfd_boolean dynamic;
1293 struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1294 PTR allocated = NULL;
1295 bfd_byte *native_relocs;
1299 unsigned int symcount;
1301 allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
1302 if (allocated == NULL)
1305 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1306 || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
1307 != rel_hdr->sh_size))
1310 native_relocs = (bfd_byte *) allocated;
1312 entsize = rel_hdr->sh_entsize;
1313 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1314 || entsize == sizeof (Elf_External_Rela));
1317 symcount = bfd_get_dynamic_symcount (abfd);
1319 symcount = bfd_get_symcount (abfd);
1321 for (i = 0, relent = relents;
1323 i++, relent++, native_relocs += entsize)
1325 Elf_Internal_Rela rela;
1327 if (entsize == sizeof (Elf_External_Rela))
1328 elf_swap_reloca_in (abfd, native_relocs, &rela);
1330 elf_swap_reloc_in (abfd, native_relocs, &rela);
1332 /* The address of an ELF reloc is section relative for an object
1333 file, and absolute for an executable file or shared library.
1334 The address of a normal BFD reloc is always section relative,
1335 and the address of a dynamic reloc is absolute.. */
1336 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1337 relent->address = rela.r_offset;
1339 relent->address = rela.r_offset - asect->vma;
1341 if (ELF_R_SYM (rela.r_info) == 0)
1342 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1343 else if (ELF_R_SYM (rela.r_info) > symcount)
1345 (*_bfd_error_handler)
1346 (_("%s(%s): relocation %d has invalid symbol index %ld"),
1347 abfd->filename, asect->name, i, ELF_R_SYM (rela.r_info));
1348 relent->sym_ptr_ptr = bfd_abs_section.symbol_ptr_ptr;
1354 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1357 /* Canonicalize ELF section symbols. FIXME: Why? */
1358 if ((s->flags & BSF_SECTION_SYM) == 0)
1359 relent->sym_ptr_ptr = ps;
1361 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1364 relent->addend = rela.r_addend;
1366 if (entsize == sizeof (Elf_External_Rela))
1367 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1369 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rela);
1372 if (allocated != NULL)
1378 if (allocated != NULL)
1383 /* Read in and swap the external relocs. */
1386 elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1390 bfd_boolean dynamic;
1392 struct bfd_elf_section_data * const d = elf_section_data (asect);
1393 Elf_Internal_Shdr *rel_hdr;
1394 Elf_Internal_Shdr *rel_hdr2;
1395 bfd_size_type reloc_count;
1396 bfd_size_type reloc_count2;
1400 if (asect->relocation != NULL)
1405 if ((asect->flags & SEC_RELOC) == 0
1406 || asect->reloc_count == 0)
1409 rel_hdr = &d->rel_hdr;
1410 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1411 rel_hdr2 = d->rel_hdr2;
1412 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1414 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1415 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1416 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1421 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1422 case because relocations against this section may use the
1423 dynamic symbol table, and in that case bfd_section_from_shdr
1424 in elf.c does not update the RELOC_COUNT. */
1425 if (asect->_raw_size == 0)
1428 rel_hdr = &d->this_hdr;
1429 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1434 amt = (reloc_count + reloc_count2) * sizeof (arelent);
1435 relents = (arelent *) bfd_alloc (abfd, amt);
1436 if (relents == NULL)
1439 if (!elf_slurp_reloc_table_from_section (abfd, asect,
1440 rel_hdr, reloc_count,
1446 && !elf_slurp_reloc_table_from_section (abfd, asect,
1447 rel_hdr2, reloc_count2,
1448 relents + reloc_count,
1452 asect->relocation = relents;
1458 elf_debug_section (num, hdr)
1460 Elf_Internal_Shdr *hdr;
1462 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1463 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1466 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1467 (long) hdr->sh_name,
1468 (long) hdr->sh_type,
1469 (long) hdr->sh_flags);
1471 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1472 (long) hdr->sh_addr,
1473 (long) hdr->sh_offset,
1474 (long) hdr->sh_size);
1476 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1477 (long) hdr->sh_link,
1478 (long) hdr->sh_info,
1479 (long) hdr->sh_addralign);
1480 fprintf (stderr, "sh_entsize = %ld\n",
1481 (long) hdr->sh_entsize);
1486 elf_debug_file (ehdrp)
1487 Elf_Internal_Ehdr *ehdrp;
1489 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1490 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1491 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1492 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1493 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1494 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1495 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1499 elf_symbol_flags (flags)
1502 static char buffer[1024];
1505 if (flags & BSF_LOCAL)
1506 strcat (buffer, " local");
1508 if (flags & BSF_GLOBAL)
1509 strcat (buffer, " global");
1511 if (flags & BSF_DEBUGGING)
1512 strcat (buffer, " debug");
1514 if (flags & BSF_FUNCTION)
1515 strcat (buffer, " function");
1517 if (flags & BSF_KEEP)
1518 strcat (buffer, " keep");
1520 if (flags & BSF_KEEP_G)
1521 strcat (buffer, " keep_g");
1523 if (flags & BSF_WEAK)
1524 strcat (buffer, " weak");
1526 if (flags & BSF_SECTION_SYM)
1527 strcat (buffer, " section-sym");
1529 if (flags & BSF_OLD_COMMON)
1530 strcat (buffer, " old-common");
1532 if (flags & BSF_NOT_AT_END)
1533 strcat (buffer, " not-at-end");
1535 if (flags & BSF_CONSTRUCTOR)
1536 strcat (buffer, " constructor");
1538 if (flags & BSF_WARNING)
1539 strcat (buffer, " warning");
1541 if (flags & BSF_INDIRECT)
1542 strcat (buffer, " indirect");
1544 if (flags & BSF_FILE)
1545 strcat (buffer, " file");
1547 if (flags & DYNAMIC)
1548 strcat (buffer, " dynamic");
1550 if (flags & ~(BSF_LOCAL
1565 strcat (buffer, " unknown-bits");
1571 #include "elfcore.h"
1572 #include "elflink.h"
1574 /* Size-dependent data and functions. */
1575 const struct elf_size_info NAME(_bfd_elf,size_info) = {
1576 sizeof (Elf_External_Ehdr),
1577 sizeof (Elf_External_Phdr),
1578 sizeof (Elf_External_Shdr),
1579 sizeof (Elf_External_Rel),
1580 sizeof (Elf_External_Rela),
1581 sizeof (Elf_External_Sym),
1582 sizeof (Elf_External_Dyn),
1583 sizeof (Elf_External_Note),
1586 ARCH_SIZE, LOG_FILE_ALIGN,
1587 ELFCLASS, EV_CURRENT,
1588 elf_write_out_phdrs,
1589 elf_write_shdrs_and_ehdr,
1592 elf_swap_symbol_out,
1593 elf_slurp_reloc_table,
1594 elf_slurp_symbol_table,