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
)
498 goto got_no_memory_error
;
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
))
572 goto got_no_memory_error
;
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 string table containing the names of the sections. We
589 will need the base pointer to this table later. */
590 /* We read this inline now, so that we don't have to go through
591 bfd_section_from_shdr with it (since this particular strtab is
592 used to find all of the ELF section names.) */
594 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
598 /* Once all of the section headers have been read and converted, we
599 can start processing them. Note that the first section header is
600 a dummy placeholder entry, so we ignore it. */
602 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
604 if (! bfd_section_from_shdr (abfd
, shindex
))
608 /* Let the backend double check the format and override global
610 if (ebd
->elf_backend_object_p
)
612 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
613 goto got_wrong_format_error
;
618 got_wrong_format_error
:
619 bfd_set_error (bfd_error_wrong_format
);
622 bfd_set_error (bfd_error_no_memory
);
625 if (new_tdata
!= NULL
626 && new_tdata
->elf_sect_ptr
!= NULL
)
627 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
629 bfd_release (abfd
, i_shdrp
);
630 if (new_tdata
!= NULL
)
631 bfd_release (abfd
, new_tdata
);
632 elf_tdata (abfd
) = preserved_tdata
;
637 /* ELF .o/exec file writing */
640 write_relocs (abfd
, sec
, data
)
645 boolean
*failedp
= (boolean
*) data
;
646 Elf_Internal_Shdr
*rela_hdr
;
647 Elf_External_Rela
*outbound_relocas
;
648 Elf_External_Rel
*outbound_relocs
;
650 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
651 asymbol
*last_sym
= 0;
652 int last_sym_idx
= 9999999; /* should always be written before use */
654 /* If we have already failed, don't do anything. */
658 if ((sec
->flags
& SEC_RELOC
) == 0)
661 /* The linker backend writes the relocs out itself, and sets the
662 reloc_count field to zero to inhibit writing them here. Also,
663 sometimes the SEC_RELOC flag gets set even when there aren't any
665 if (sec
->reloc_count
== 0)
668 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
670 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
671 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
672 if (rela_hdr
->contents
== NULL
)
674 bfd_set_error (bfd_error_no_memory
);
679 /* orelocation has the data, reloc_count has the count... */
682 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
684 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
686 Elf_Internal_Rela dst_rela
;
687 Elf_External_Rela
*src_rela
;
692 ptr
= sec
->orelocation
[idx
];
693 src_rela
= outbound_relocas
+ idx
;
695 /* The address of an ELF reloc is section relative for an object
696 file, and absolute for an executable file or shared library.
697 The address of a BFD reloc is always section relative. */
698 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
699 dst_rela
.r_offset
= ptr
->address
;
701 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
703 sym
= *ptr
->sym_ptr_ptr
;
709 last_sym_idx
= n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
711 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
713 dst_rela
.r_addend
= ptr
->addend
;
714 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
718 /* REL relocations */
720 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
722 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
724 Elf_Internal_Rel dst_rel
;
725 Elf_External_Rel
*src_rel
;
730 ptr
= sec
->orelocation
[idx
];
731 sym
= *ptr
->sym_ptr_ptr
;
732 src_rel
= outbound_relocs
+ idx
;
734 /* The address of an ELF reloc is section relative for an object
735 file, and absolute for an executable file or shared library.
736 The address of a BFD reloc is always section relative. */
737 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
738 dst_rel
.r_offset
= ptr
->address
;
740 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
747 last_sym_idx
= n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
749 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
751 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
757 write_out_phdrs (abfd
, phdr
, count
)
759 Elf_Internal_Phdr
*phdr
;
764 Elf_External_Phdr extphdr
;
765 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
766 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
767 != sizeof (Elf_External_Phdr
))
775 write_shdrs_and_ehdr (abfd
)
778 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
779 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
780 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
781 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
784 i_ehdrp
= elf_elfheader (abfd
);
785 i_shdrp
= elf_elfsections (abfd
);
787 /* swap the header before spitting it out... */
790 elf_debug_file (i_ehdrp
);
792 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
793 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
794 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
798 /* at this point we've concocted all the ELF sections... */
799 x_shdrp
= (Elf_External_Shdr
*)
800 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
803 bfd_set_error (bfd_error_no_memory
);
807 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
810 elf_debug_section (count
, i_shdrp
[count
]);
812 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
814 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
815 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
816 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
819 /* need to dump the string table too... */
825 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
827 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
830 Elf_Internal_Shdr
*hdr
;
831 long symcount
; /* Number of external ELF symbols */
832 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
833 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
834 Elf_Internal_Sym i_sym
;
835 Elf_External_Sym
*x_symp
= NULL
;
837 /* Read each raw ELF symbol, converting from external ELF form to
838 internal ELF form, and then using the information to create a
839 canonical bfd symbol table entry.
841 Note that we allocate the initial bfd canonical symbol buffer
842 based on a one-to-one mapping of the ELF symbols to canonical
843 symbols. We actually use all the ELF symbols, so there will be no
844 space left over at the end. When we have all the symbols, we
845 build the caller's pointer vector. */
848 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
850 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
851 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
854 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
857 sym
= symbase
= NULL
;
862 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
865 symbase
= ((elf_symbol_type
*)
866 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
867 if (symbase
== (elf_symbol_type
*) NULL
)
869 bfd_set_error (bfd_error_no_memory
);
874 /* Temporarily allocate room for the raw ELF symbols. */
875 x_symp
= ((Elf_External_Sym
*)
876 malloc (symcount
* sizeof (Elf_External_Sym
)));
877 if (x_symp
== NULL
&& symcount
!= 0)
879 bfd_set_error (bfd_error_no_memory
);
883 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
884 != symcount
* sizeof (Elf_External_Sym
))
886 /* Skip first symbol, which is a null dummy. */
887 for (i
= 1; i
< symcount
; i
++)
889 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
890 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
891 #ifdef ELF_KEEP_EXTSYM
892 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
894 sym
->symbol
.the_bfd
= abfd
;
896 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
900 sym
->symbol
.value
= i_sym
.st_value
;
902 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
904 sym
->symbol
.section
= section_from_elf_index (abfd
,
906 if (sym
->symbol
.section
== NULL
)
908 /* This symbol is in a section for which we did not
909 create a BFD section. Just use bfd_abs_section,
910 although it is wrong. FIXME. */
911 sym
->symbol
.section
= bfd_abs_section_ptr
;
914 else if (i_sym
.st_shndx
== SHN_ABS
)
916 sym
->symbol
.section
= bfd_abs_section_ptr
;
918 else if (i_sym
.st_shndx
== SHN_COMMON
)
920 sym
->symbol
.section
= bfd_com_section_ptr
;
921 /* Elf puts the alignment into the `value' field, and
922 the size into the `size' field. BFD wants to see the
923 size in the value field, and doesn't care (at the
924 moment) about the alignment. */
925 sym
->symbol
.value
= i_sym
.st_size
;
927 else if (i_sym
.st_shndx
== SHN_UNDEF
)
929 sym
->symbol
.section
= bfd_und_section_ptr
;
932 sym
->symbol
.section
= bfd_abs_section_ptr
;
934 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
936 switch (ELF_ST_BIND (i_sym
.st_info
))
939 sym
->symbol
.flags
|= BSF_LOCAL
;
942 if (i_sym
.st_shndx
!= SHN_UNDEF
943 && i_sym
.st_shndx
!= SHN_COMMON
)
944 sym
->symbol
.flags
|= BSF_GLOBAL
;
947 sym
->symbol
.flags
|= BSF_WEAK
;
951 switch (ELF_ST_TYPE (i_sym
.st_info
))
954 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
957 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
960 sym
->symbol
.flags
|= BSF_FUNCTION
;
965 sym
->symbol
.flags
|= BSF_DYNAMIC
;
967 /* Do some backend-specific processing on this symbol. */
969 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
970 if (ebd
->elf_backend_symbol_processing
)
971 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
978 /* Do some backend-specific processing on this symbol table. */
980 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
981 if (ebd
->elf_backend_symbol_table_processing
)
982 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
985 /* We rely on the zalloc to clear out the final symbol entry. */
987 symcount
= sym
- symbase
;
989 /* Fill in the user's symbol pointer vector if needed. */
997 *symptrs
++ = &sym
->symbol
;
1000 *symptrs
= 0; /* Final null pointer */
1012 /* Read in and swap the external relocs. */
1015 elf_slurp_reloc_table (abfd
, asect
, symbols
)
1020 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1021 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1022 PTR allocated
= NULL
;
1023 bfd_byte
*native_relocs
;
1029 if (asect
->relocation
!= NULL
1030 || (asect
->flags
& SEC_RELOC
) == 0
1031 || asect
->reloc_count
== 0)
1034 BFD_ASSERT (asect
->rel_filepos
== d
->rel_hdr
.sh_offset
1035 && (asect
->reloc_count
1036 == d
->rel_hdr
.sh_size
/ d
->rel_hdr
.sh_entsize
));
1038 allocated
= (PTR
) malloc ((size_t) d
->rel_hdr
.sh_size
);
1039 if (allocated
== NULL
)
1041 bfd_set_error (bfd_error_no_memory
);
1045 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0
1046 || (bfd_read (allocated
, 1, d
->rel_hdr
.sh_size
, abfd
)
1047 != d
->rel_hdr
.sh_size
))
1050 native_relocs
= (bfd_byte
*) allocated
;
1052 relents
= ((arelent
*)
1053 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (arelent
)));
1054 if (relents
== NULL
)
1056 bfd_set_error (bfd_error_no_memory
);
1060 entsize
= d
->rel_hdr
.sh_entsize
;
1061 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1062 || entsize
== sizeof (Elf_External_Rela
));
1064 for (i
= 0, relent
= relents
;
1065 i
< asect
->reloc_count
;
1066 i
++, relent
++, native_relocs
+= entsize
)
1068 Elf_Internal_Rela rela
;
1069 Elf_Internal_Rel rel
;
1071 if (entsize
== sizeof (Elf_External_Rela
))
1072 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
1075 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
1076 rela
.r_offset
= rel
.r_offset
;
1077 rela
.r_info
= rel
.r_info
;
1081 /* The address of an ELF reloc is section relative for an object
1082 file, and absolute for an executable file or shared library.
1083 The address of a BFD reloc is always section relative. */
1084 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
1085 relent
->address
= rela
.r_offset
;
1087 relent
->address
= rela
.r_offset
- asect
->vma
;
1089 if (ELF_R_SYM (rela
.r_info
) == 0)
1090 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1095 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1098 /* Canonicalize ELF section symbols. FIXME: Why? */
1099 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1100 relent
->sym_ptr_ptr
= ps
;
1102 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1105 relent
->addend
= rela
.r_addend
;
1107 if (entsize
== sizeof (Elf_External_Rela
))
1108 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1110 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
1113 asect
->relocation
= relents
;
1115 if (allocated
!= NULL
)
1121 if (allocated
!= NULL
)
1128 elf_debug_section (num
, hdr
)
1130 Elf_Internal_Shdr
*hdr
;
1132 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1133 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1136 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1137 (long) hdr
->sh_name
,
1138 (long) hdr
->sh_type
,
1139 (long) hdr
->sh_flags
);
1141 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1142 (long) hdr
->sh_addr
,
1143 (long) hdr
->sh_offset
,
1144 (long) hdr
->sh_size
);
1146 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1147 (long) hdr
->sh_link
,
1148 (long) hdr
->sh_info
,
1149 (long) hdr
->sh_addralign
);
1150 fprintf (stderr
, "sh_entsize = %ld\n",
1151 (long) hdr
->sh_entsize
);
1156 elf_debug_file (ehdrp
)
1157 Elf_Internal_Ehdr
*ehdrp
;
1159 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1160 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1161 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1162 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1163 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1164 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1165 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1169 elf_symbol_flags (flags
)
1172 static char buffer
[1024];
1175 if (flags
& BSF_LOCAL
)
1176 strcat (buffer
, " local");
1178 if (flags
& BSF_GLOBAL
)
1179 strcat (buffer
, " global");
1181 if (flags
& BSF_DEBUGGING
)
1182 strcat (buffer
, " debug");
1184 if (flags
& BSF_FUNCTION
)
1185 strcat (buffer
, " function");
1187 if (flags
& BSF_KEEP
)
1188 strcat (buffer
, " keep");
1190 if (flags
& BSF_KEEP_G
)
1191 strcat (buffer
, " keep_g");
1193 if (flags
& BSF_WEAK
)
1194 strcat (buffer
, " weak");
1196 if (flags
& BSF_SECTION_SYM
)
1197 strcat (buffer
, " section-sym");
1199 if (flags
& BSF_OLD_COMMON
)
1200 strcat (buffer
, " old-common");
1202 if (flags
& BSF_NOT_AT_END
)
1203 strcat (buffer
, " not-at-end");
1205 if (flags
& BSF_CONSTRUCTOR
)
1206 strcat (buffer
, " constructor");
1208 if (flags
& BSF_WARNING
)
1209 strcat (buffer
, " warning");
1211 if (flags
& BSF_INDIRECT
)
1212 strcat (buffer
, " indirect");
1214 if (flags
& BSF_FILE
)
1215 strcat (buffer
, " file");
1217 if (flags
& DYNAMIC
)
1218 strcat (buffer
, " dynamic");
1220 if (flags
& ~(BSF_LOCAL
1235 strcat (buffer
, " unknown-bits");
1241 #include "elfcore.h"
1242 #include "elflink.h"
1244 /* Size-dependent data and functions. */
1245 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1246 sizeof (Elf_External_Ehdr
),
1247 sizeof (Elf_External_Phdr
),
1248 sizeof (Elf_External_Shdr
),
1249 sizeof (Elf_External_Rel
),
1250 sizeof (Elf_External_Rela
),
1251 sizeof (Elf_External_Sym
),
1252 sizeof (Elf_External_Dyn
),
1253 sizeof (Elf_External_Note
),
1255 ARCH_SIZE
, FILE_ALIGN
,
1256 ELFCLASS
, EV_CURRENT
,
1258 write_shdrs_and_ehdr
,
1260 elf_swap_symbol_out
,
1261 elf_slurp_reloc_table
,
1262 elf_slurp_symbol_table
,