1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
61 (4) We need a published spec for 64-bit ELF. We've got some stuff here
62 that we're using for SPARC V9 64-bit chips, but don't assume that
66 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
80 #define Elf_External_Dyn NAME(Elf,External_Dyn)
82 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
83 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
84 #define elf_core_file_matches_executable_p \
85 NAME(bfd_elf,core_file_matches_executable_p)
86 #define elf_object_p NAME(bfd_elf,object_p)
87 #define elf_core_file_p NAME(bfd_elf,core_file_p)
88 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
89 #define elf_get_dynamic_symtab_upper_bound \
90 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
91 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
92 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
93 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
94 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
95 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
96 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
97 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
98 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
99 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
100 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
101 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
102 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
103 #define elf_get_symtab NAME(bfd_elf,get_symtab)
104 #define elf_canonicalize_dynamic_symtab \
105 NAME(bfd_elf,canonicalize_dynamic_symtab)
106 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
107 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
108 #define elf_get_lineno NAME(bfd_elf,get_lineno)
109 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
110 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
111 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
112 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
113 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
114 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
115 #define elf_find_section NAME(bfd_elf,find_section)
116 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
117 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
118 #define elf_link_create_dynamic_sections \
119 NAME(bfd_elf,link_create_dynamic_sections)
120 #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
121 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
124 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
125 #define ELF_R_SYM(X) ELF64_R_SYM(X)
126 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
127 #define ELFCLASS ELFCLASS64
129 #define LOG_FILE_ALIGN 3
132 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
133 #define ELF_R_SYM(X) ELF32_R_SYM(X)
134 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
135 #define ELFCLASS ELFCLASS32
137 #define LOG_FILE_ALIGN 2
140 /* Forward declarations of static functions */
142 #define elf_stringtab_init _bfd_elf_stringtab_init
144 extern struct bfd_strtab_hash
*_bfd_elf_stringtab_init
PARAMS ((void));
145 #define section_from_elf_index bfd_section_from_elf_index
146 extern boolean bfd_section_from_phdr
PARAMS ((bfd
*, Elf_Internal_Phdr
*,
149 int _bfd_elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
151 static long elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**, boolean
));
153 static boolean elf_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
155 int _bfd_elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
156 struct symbol_cache_entry
**));
158 static void write_relocs
PARAMS ((bfd
*, asection
*, PTR
));
160 boolean bfd_section_from_shdr
PARAMS ((bfd
*, unsigned int shindex
));
163 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
164 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
165 static char *elf_symbol_flags
PARAMS ((flagword
));
168 /* Structure swapping routines */
170 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
171 can be handled by explicitly specifying 32 bits or "the long type". */
173 #define put_word bfd_h_put_64
174 #define get_word bfd_h_get_64
177 #define put_word bfd_h_put_32
178 #define get_word bfd_h_get_32
181 /* Translate an ELF symbol in external format into an ELF symbol in internal
185 elf_swap_symbol_in (abfd
, src
, dst
)
187 Elf_External_Sym
*src
;
188 Elf_Internal_Sym
*dst
;
190 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
191 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
192 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
193 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
194 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
195 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
198 /* Translate an ELF symbol in internal format into an ELF symbol in external
202 elf_swap_symbol_out (abfd
, src
, cdst
)
204 Elf_Internal_Sym
*src
;
207 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
208 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
209 put_word (abfd
, src
->st_value
, dst
->st_value
);
210 put_word (abfd
, src
->st_size
, dst
->st_size
);
211 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
212 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
213 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
217 /* Translate an ELF file header in external format into an ELF file header in
221 elf_swap_ehdr_in (abfd
, src
, dst
)
223 Elf_External_Ehdr
*src
;
224 Elf_Internal_Ehdr
*dst
;
226 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
227 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
228 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
229 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
230 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
231 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
232 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
233 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
234 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
235 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
236 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
237 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
238 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
239 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
242 /* Translate an ELF file header in internal format into an ELF file header in
246 elf_swap_ehdr_out (abfd
, src
, dst
)
248 Elf_Internal_Ehdr
*src
;
249 Elf_External_Ehdr
*dst
;
251 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
252 /* note that all elements of dst are *arrays of unsigned char* already... */
253 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
254 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
255 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
256 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
257 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
258 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
259 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
260 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
261 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
262 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
263 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
264 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
265 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
269 /* Translate an ELF section header table entry in external format into an
270 ELF section header table entry in internal format. */
273 elf_swap_shdr_in (abfd
, src
, dst
)
275 Elf_External_Shdr
*src
;
276 Elf_Internal_Shdr
*dst
;
278 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
279 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
280 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
281 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
282 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
283 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
284 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
285 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
286 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
287 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
288 dst
->bfd_section
= NULL
;
289 dst
->contents
= NULL
;
292 /* Translate an ELF section header table entry in internal format into an
293 ELF section header table entry in external format. */
296 elf_swap_shdr_out (abfd
, src
, dst
)
298 Elf_Internal_Shdr
*src
;
299 Elf_External_Shdr
*dst
;
301 /* note that all elements of dst are *arrays of unsigned char* already... */
302 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
303 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
304 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
305 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
306 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
307 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
308 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
309 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
310 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
311 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
315 /* Translate an ELF program header table entry in external format into an
316 ELF program header table entry in internal format. */
319 elf_swap_phdr_in (abfd
, src
, dst
)
321 Elf_External_Phdr
*src
;
322 Elf_Internal_Phdr
*dst
;
324 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
325 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
326 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
327 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
328 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
329 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
330 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
331 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
335 elf_swap_phdr_out (abfd
, src
, dst
)
337 Elf_Internal_Phdr
*src
;
338 Elf_External_Phdr
*dst
;
340 /* note that all elements of dst are *arrays of unsigned char* already... */
341 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
342 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
343 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
344 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
345 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
346 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
347 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
348 put_word (abfd
, src
->p_align
, dst
->p_align
);
351 /* Translate an ELF reloc from external format to internal format. */
353 elf_swap_reloc_in (abfd
, src
, dst
)
355 Elf_External_Rel
*src
;
356 Elf_Internal_Rel
*dst
;
358 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
359 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
363 elf_swap_reloca_in (abfd
, src
, dst
)
365 Elf_External_Rela
*src
;
366 Elf_Internal_Rela
*dst
;
368 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
369 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
370 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
373 /* Translate an ELF reloc from internal format to external format. */
375 elf_swap_reloc_out (abfd
, src
, dst
)
377 Elf_Internal_Rel
*src
;
378 Elf_External_Rel
*dst
;
380 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
381 put_word (abfd
, src
->r_info
, dst
->r_info
);
385 elf_swap_reloca_out (abfd
, src
, dst
)
387 Elf_Internal_Rela
*src
;
388 Elf_External_Rela
*dst
;
390 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
391 put_word (abfd
, src
->r_info
, dst
->r_info
);
392 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
396 elf_swap_dyn_in (abfd
, src
, dst
)
398 const Elf_External_Dyn
*src
;
399 Elf_Internal_Dyn
*dst
;
401 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
402 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
406 elf_swap_dyn_out (abfd
, src
, dst
)
408 const Elf_Internal_Dyn
*src
;
409 Elf_External_Dyn
*dst
;
411 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
412 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
415 /* ELF .o/exec file reading */
418 /* Begin processing a given object.
420 First we validate the file by reading in the ELF header and checking
423 static INLINE boolean
425 Elf_External_Ehdr
*x_ehdrp
;
427 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
428 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
429 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
430 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
433 /* Check to see if the file associated with ABFD matches the target vector
436 Note that we may be called several times with the same ABFD, but different
437 target vectors, most of which will not match. We have to avoid leaving
438 any side effects in ABFD, or any data it points to (like tdata), if the
439 file does not match the target vector. */
445 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
446 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
447 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
448 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
449 unsigned int shindex
;
450 char *shstrtab
; /* Internal copy of section header stringtab */
451 struct elf_backend_data
*ebd
;
452 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
453 struct elf_obj_tdata
*new_tdata
= NULL
;
455 /* Read in the ELF header in external format. */
457 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
459 if (bfd_get_error () != bfd_error_system_call
)
460 goto got_wrong_format_error
;
465 /* Now check to see if we have a valid ELF file, and one that BFD can
466 make use of. The magic number must match, the address size ('class')
467 and byte-swapping must match our XVEC entry, and it must have a
468 section header table (FIXME: See comments re sections at top of this
471 if ((elf_file_p (&x_ehdr
) == false) ||
472 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
473 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
474 goto got_wrong_format_error
;
476 /* Check that file's byte order matches xvec's */
477 switch (x_ehdr
.e_ident
[EI_DATA
])
479 case ELFDATA2MSB
: /* Big-endian */
480 if (!abfd
->xvec
->header_byteorder_big_p
)
481 goto got_wrong_format_error
;
483 case ELFDATA2LSB
: /* Little-endian */
484 if (abfd
->xvec
->header_byteorder_big_p
)
485 goto got_wrong_format_error
;
487 case ELFDATANONE
: /* No data encoding specified */
488 default: /* Unknown data encoding specified */
489 goto got_wrong_format_error
;
492 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
493 the tdata pointer in the bfd. */
495 new_tdata
= ((struct elf_obj_tdata
*)
496 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
497 if (new_tdata
== NULL
)
499 elf_tdata (abfd
) = new_tdata
;
501 /* Now that we know the byte order, swap in the rest of the header */
502 i_ehdrp
= elf_elfheader (abfd
);
503 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
505 elf_debug_file (i_ehdrp
);
508 /* If there is no section header table, we're hosed. */
509 if (i_ehdrp
->e_shoff
== 0)
510 goto got_wrong_format_error
;
512 /* As a simple sanity check, verify that the what BFD thinks is the
513 size of each section header table entry actually matches the size
514 recorded in the file. */
515 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
516 goto got_wrong_format_error
;
518 ebd
= get_elf_backend_data (abfd
);
520 /* Check that the ELF e_machine field matches what this particular
521 BFD format expects. */
522 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
523 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
524 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
526 const bfd_target
* const *target_ptr
;
528 if (ebd
->elf_machine_code
!= EM_NONE
)
529 goto got_wrong_format_error
;
531 /* This is the generic ELF target. Let it match any ELF target
532 for which we do not have a specific backend. */
533 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
535 struct elf_backend_data
*back
;
537 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
539 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
540 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
542 /* target_ptr is an ELF backend which matches this
543 object file, so reject the generic ELF target. */
544 goto got_wrong_format_error
;
549 if (i_ehdrp
->e_type
== ET_EXEC
)
550 abfd
->flags
|= EXEC_P
;
551 else if (i_ehdrp
->e_type
== ET_DYN
)
552 abfd
->flags
|= DYNAMIC
;
554 if (i_ehdrp
->e_phnum
> 0)
555 abfd
->flags
|= D_PAGED
;
557 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
560 /* Remember the entry point specified in the ELF file header. */
561 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
563 /* Allocate space for a copy of the section header table in
564 internal form, seek to the section header table in the file,
565 read it in, and convert it to internal form. */
566 i_shdrp
= ((Elf_Internal_Shdr
*)
567 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
568 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
570 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
571 if (!i_shdrp
|| !elf_elfsections (abfd
))
573 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
575 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
577 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
579 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
580 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
582 if (i_ehdrp
->e_shstrndx
)
584 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
588 /* Read in the program headers. */
589 if (i_ehdrp
->e_phnum
== 0)
590 elf_tdata (abfd
)->phdr
= NULL
;
593 Elf_Internal_Phdr
*i_phdr
;
596 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
599 * sizeof (Elf_Internal_Phdr
))));
600 if (elf_tdata (abfd
)->phdr
== NULL
)
602 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
604 i_phdr
= elf_tdata (abfd
)->phdr
;
605 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
607 Elf_External_Phdr x_phdr
;
609 if (bfd_read ((PTR
) &x_phdr
, sizeof x_phdr
, 1, abfd
)
612 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
616 /* Read in the string table containing the names of the sections. We
617 will need the base pointer to this table later. */
618 /* We read this inline now, so that we don't have to go through
619 bfd_section_from_shdr with it (since this particular strtab is
620 used to find all of the ELF section names.) */
622 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
626 /* Once all of the section headers have been read and converted, we
627 can start processing them. Note that the first section header is
628 a dummy placeholder entry, so we ignore it. */
630 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
632 if (! bfd_section_from_shdr (abfd
, shindex
))
636 /* Let the backend double check the format and override global
638 if (ebd
->elf_backend_object_p
)
640 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
641 goto got_wrong_format_error
;
646 got_wrong_format_error
:
647 bfd_set_error (bfd_error_wrong_format
);
650 if (new_tdata
!= NULL
651 && new_tdata
->elf_sect_ptr
!= NULL
)
652 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
654 bfd_release (abfd
, i_shdrp
);
655 if (new_tdata
!= NULL
)
656 bfd_release (abfd
, new_tdata
);
657 elf_tdata (abfd
) = preserved_tdata
;
662 /* ELF .o/exec file writing */
665 write_relocs (abfd
, sec
, data
)
670 boolean
*failedp
= (boolean
*) data
;
671 Elf_Internal_Shdr
*rela_hdr
;
672 Elf_External_Rela
*outbound_relocas
;
673 Elf_External_Rel
*outbound_relocs
;
675 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
676 asymbol
*last_sym
= 0;
677 int last_sym_idx
= 9999999; /* should always be written before use */
679 /* If we have already failed, don't do anything. */
683 if ((sec
->flags
& SEC_RELOC
) == 0)
686 /* The linker backend writes the relocs out itself, and sets the
687 reloc_count field to zero to inhibit writing them here. Also,
688 sometimes the SEC_RELOC flag gets set even when there aren't any
690 if (sec
->reloc_count
== 0)
693 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
695 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
696 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
697 if (rela_hdr
->contents
== NULL
)
703 /* orelocation has the data, reloc_count has the count... */
706 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
708 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
710 Elf_Internal_Rela dst_rela
;
711 Elf_External_Rela
*src_rela
;
716 ptr
= sec
->orelocation
[idx
];
717 src_rela
= outbound_relocas
+ idx
;
719 /* The address of an ELF reloc is section relative for an object
720 file, and absolute for an executable file or shared library.
721 The address of a BFD reloc is always section relative. */
722 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
723 dst_rela
.r_offset
= ptr
->address
;
725 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
727 sym
= *ptr
->sym_ptr_ptr
;
733 last_sym_idx
= n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
735 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
737 dst_rela
.r_addend
= ptr
->addend
;
738 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
742 /* REL relocations */
744 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
746 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
748 Elf_Internal_Rel dst_rel
;
749 Elf_External_Rel
*src_rel
;
754 ptr
= sec
->orelocation
[idx
];
755 sym
= *ptr
->sym_ptr_ptr
;
756 src_rel
= outbound_relocs
+ idx
;
758 /* The address of an ELF reloc is section relative for an object
759 file, and absolute for an executable file or shared library.
760 The address of a BFD reloc is always section relative. */
761 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
762 dst_rel
.r_offset
= ptr
->address
;
764 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
771 last_sym_idx
= n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
773 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
775 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
781 write_out_phdrs (abfd
, phdr
, count
)
783 Elf_Internal_Phdr
*phdr
;
788 Elf_External_Phdr extphdr
;
789 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
790 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
791 != sizeof (Elf_External_Phdr
))
799 write_shdrs_and_ehdr (abfd
)
802 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
803 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
804 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
805 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
808 i_ehdrp
= elf_elfheader (abfd
);
809 i_shdrp
= elf_elfsections (abfd
);
811 /* swap the header before spitting it out... */
814 elf_debug_file (i_ehdrp
);
816 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
817 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
818 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
822 /* at this point we've concocted all the ELF sections... */
823 x_shdrp
= (Elf_External_Shdr
*)
824 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
828 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
831 elf_debug_section (count
, i_shdrp
[count
]);
833 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
835 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
836 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
837 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
840 /* need to dump the string table too... */
846 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
848 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
851 Elf_Internal_Shdr
*hdr
;
852 long symcount
; /* Number of external ELF symbols */
853 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
854 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
855 Elf_Internal_Sym i_sym
;
856 Elf_External_Sym
*x_symp
= NULL
;
858 /* Read each raw ELF symbol, converting from external ELF form to
859 internal ELF form, and then using the information to create a
860 canonical bfd symbol table entry.
862 Note that we allocate the initial bfd canonical symbol buffer
863 based on a one-to-one mapping of the ELF symbols to canonical
864 symbols. We actually use all the ELF symbols, so there will be no
865 space left over at the end. When we have all the symbols, we
866 build the caller's pointer vector. */
869 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
871 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
872 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
875 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
878 sym
= symbase
= NULL
;
883 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
886 symbase
= ((elf_symbol_type
*)
887 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
888 if (symbase
== (elf_symbol_type
*) NULL
)
892 /* Temporarily allocate room for the raw ELF symbols. */
893 x_symp
= ((Elf_External_Sym
*)
894 malloc (symcount
* sizeof (Elf_External_Sym
)));
895 if (x_symp
== NULL
&& symcount
!= 0)
897 bfd_set_error (bfd_error_no_memory
);
901 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
902 != symcount
* sizeof (Elf_External_Sym
))
904 /* Skip first symbol, which is a null dummy. */
905 for (i
= 1; i
< symcount
; i
++)
907 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
908 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
909 #ifdef ELF_KEEP_EXTSYM
910 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
912 sym
->symbol
.the_bfd
= abfd
;
914 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
918 sym
->symbol
.value
= i_sym
.st_value
;
920 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
922 sym
->symbol
.section
= section_from_elf_index (abfd
,
924 if (sym
->symbol
.section
== NULL
)
926 /* This symbol is in a section for which we did not
927 create a BFD section. Just use bfd_abs_section,
928 although it is wrong. FIXME. */
929 sym
->symbol
.section
= bfd_abs_section_ptr
;
932 else if (i_sym
.st_shndx
== SHN_ABS
)
934 sym
->symbol
.section
= bfd_abs_section_ptr
;
936 else if (i_sym
.st_shndx
== SHN_COMMON
)
938 sym
->symbol
.section
= bfd_com_section_ptr
;
939 /* Elf puts the alignment into the `value' field, and
940 the size into the `size' field. BFD wants to see the
941 size in the value field, and doesn't care (at the
942 moment) about the alignment. */
943 sym
->symbol
.value
= i_sym
.st_size
;
945 else if (i_sym
.st_shndx
== SHN_UNDEF
)
947 sym
->symbol
.section
= bfd_und_section_ptr
;
950 sym
->symbol
.section
= bfd_abs_section_ptr
;
952 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
954 switch (ELF_ST_BIND (i_sym
.st_info
))
957 sym
->symbol
.flags
|= BSF_LOCAL
;
960 if (i_sym
.st_shndx
!= SHN_UNDEF
961 && i_sym
.st_shndx
!= SHN_COMMON
)
962 sym
->symbol
.flags
|= BSF_GLOBAL
;
965 sym
->symbol
.flags
|= BSF_WEAK
;
969 switch (ELF_ST_TYPE (i_sym
.st_info
))
972 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
975 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
978 sym
->symbol
.flags
|= BSF_FUNCTION
;
983 sym
->symbol
.flags
|= BSF_DYNAMIC
;
985 /* Do some backend-specific processing on this symbol. */
987 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
988 if (ebd
->elf_backend_symbol_processing
)
989 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
996 /* Do some backend-specific processing on this symbol table. */
998 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
999 if (ebd
->elf_backend_symbol_table_processing
)
1000 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1003 /* We rely on the zalloc to clear out the final symbol entry. */
1005 symcount
= sym
- symbase
;
1007 /* Fill in the user's symbol pointer vector if needed. */
1015 *symptrs
++ = &sym
->symbol
;
1018 *symptrs
= 0; /* Final null pointer */
1030 /* Read in and swap the external relocs. */
1033 elf_slurp_reloc_table (abfd
, asect
, symbols
)
1038 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1039 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1040 PTR allocated
= NULL
;
1041 bfd_byte
*native_relocs
;
1047 if (asect
->relocation
!= NULL
1048 || (asect
->flags
& SEC_RELOC
) == 0
1049 || asect
->reloc_count
== 0)
1052 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
1053 && (asect
->reloc_count
1054 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
1056 allocated
= (PTR
) malloc ((size_t) d
->rel_hdr
.sh_size
);
1057 if (allocated
== NULL
)
1059 bfd_set_error (bfd_error_no_memory
);
1063 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
1064 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
1065 != d
->rel_hdr
.sh_size
))
1068 native_relocs
= (bfd_byte
*) allocated
;
1070 relents
= ((arelent
*)
1071 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
1072 if (relents
== NULL
)
1075 entsize
= d
->rel_hdr
.sh_entsize
;
1076 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1077 || entsize
== sizeof (Elf_External_Rela
));
1079 for (i
= 0, relent
= relents
;
1080 i
< asect
->reloc_count
;
1081 i
++, relent
++, native_relocs
+= entsize
)
1083 Elf_Internal_Rela rela
;
1084 Elf_Internal_Rel rel
;
1086 if (entsize
== sizeof (Elf_External_Rela
))
1087 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
1090 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
1091 rela
.r_offset
= rel
.r_offset
;
1092 rela
.r_info
= rel
.r_info
;
1096 /* The address of an ELF reloc is section relative for an object
1097 file, and absolute for an executable file or shared library.
1098 The address of a BFD reloc is always section relative. */
1099 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1100 relent
->address
= rela
.r_offset
;
1102 relent
->address
= rela
.r_offset
- asect
->vma
;
1104 if (ELF_R_SYM (rela
.r_info
) == 0)
1105 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1110 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1113 /* Canonicalize ELF section symbols. FIXME: Why? */
1114 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1115 relent
->sym_ptr_ptr
= ps
;
1117 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1120 relent
->addend
= rela
.r_addend
;
1122 if (entsize
== sizeof (Elf_External_Rela
))
1123 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1125 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
1128 asect
->relocation
= relents
;
1130 if (allocated
!= NULL
)
1136 if (allocated
!= NULL
)
1143 elf_debug_section (num
, hdr
)
1145 Elf_Internal_Shdr
*hdr
;
1147 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1148 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1151 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1152 (long) hdr
->sh_name
,
1153 (long) hdr
->sh_type
,
1154 (long) hdr
->sh_flags
);
1156 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1157 (long) hdr
->sh_addr
,
1158 (long) hdr
->sh_offset
,
1159 (long) hdr
->sh_size
);
1161 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1162 (long) hdr
->sh_link
,
1163 (long) hdr
->sh_info
,
1164 (long) hdr
->sh_addralign
);
1165 fprintf (stderr
, "sh_entsize = %ld\n",
1166 (long) hdr
->sh_entsize
);
1171 elf_debug_file (ehdrp
)
1172 Elf_Internal_Ehdr
*ehdrp
;
1174 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1175 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1176 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1177 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1178 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1179 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1180 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1184 elf_symbol_flags (flags
)
1187 static char buffer
[1024];
1190 if (flags
& BSF_LOCAL
)
1191 strcat (buffer
, " local");
1193 if (flags
& BSF_GLOBAL
)
1194 strcat (buffer
, " global");
1196 if (flags
& BSF_DEBUGGING
)
1197 strcat (buffer
, " debug");
1199 if (flags
& BSF_FUNCTION
)
1200 strcat (buffer
, " function");
1202 if (flags
& BSF_KEEP
)
1203 strcat (buffer
, " keep");
1205 if (flags
& BSF_KEEP_G
)
1206 strcat (buffer
, " keep_g");
1208 if (flags
& BSF_WEAK
)
1209 strcat (buffer
, " weak");
1211 if (flags
& BSF_SECTION_SYM
)
1212 strcat (buffer
, " section-sym");
1214 if (flags
& BSF_OLD_COMMON
)
1215 strcat (buffer
, " old-common");
1217 if (flags
& BSF_NOT_AT_END
)
1218 strcat (buffer
, " not-at-end");
1220 if (flags
& BSF_CONSTRUCTOR
)
1221 strcat (buffer
, " constructor");
1223 if (flags
& BSF_WARNING
)
1224 strcat (buffer
, " warning");
1226 if (flags
& BSF_INDIRECT
)
1227 strcat (buffer
, " indirect");
1229 if (flags
& BSF_FILE
)
1230 strcat (buffer
, " file");
1232 if (flags
& DYNAMIC
)
1233 strcat (buffer
, " dynamic");
1235 if (flags
& ~(BSF_LOCAL
1250 strcat (buffer
, " unknown-bits");
1256 #include "elfcore.h"
1257 #include "elflink.h"
1259 /* Size-dependent data and functions. */
1260 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1261 sizeof (Elf_External_Ehdr
),
1262 sizeof (Elf_External_Phdr
),
1263 sizeof (Elf_External_Shdr
),
1264 sizeof (Elf_External_Rel
),
1265 sizeof (Elf_External_Rela
),
1266 sizeof (Elf_External_Sym
),
1267 sizeof (Elf_External_Dyn
),
1268 sizeof (Elf_External_Note
),
1270 ARCH_SIZE
, FILE_ALIGN
,
1271 ELFCLASS
, EV_CURRENT
,
1273 write_shdrs_and_ehdr
,
1275 elf_swap_symbol_out
,
1276 elf_slurp_reloc_table
,
1277 elf_slurp_symbol_table
,