1 /* ELF executable support for BFD.
2 Copyright 1991, 92, 93, 94, 95, 96, 97, 1998 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
72 /* Renaming structures, typedefs, macros and functions to be size-specific. */
73 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
74 #define Elf_External_Sym NAME(Elf,External_Sym)
75 #define Elf_External_Shdr NAME(Elf,External_Shdr)
76 #define Elf_External_Phdr NAME(Elf,External_Phdr)
77 #define Elf_External_Rel NAME(Elf,External_Rel)
78 #define Elf_External_Rela NAME(Elf,External_Rela)
79 #define Elf_External_Dyn NAME(Elf,External_Dyn)
81 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
82 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
83 #define elf_core_file_matches_executable_p \
84 NAME(bfd_elf,core_file_matches_executable_p)
85 #define elf_object_p NAME(bfd_elf,object_p)
86 #define elf_core_file_p NAME(bfd_elf,core_file_p)
87 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
88 #define elf_get_dynamic_symtab_upper_bound \
89 NAME(bfd_elf,get_dynamic_symtab_upper_bound)
90 #define elf_swap_reloc_in NAME(bfd_elf,swap_reloc_in)
91 #define elf_swap_reloca_in NAME(bfd_elf,swap_reloca_in)
92 #define elf_swap_reloc_out NAME(bfd_elf,swap_reloc_out)
93 #define elf_swap_reloca_out NAME(bfd_elf,swap_reloca_out)
94 #define elf_swap_symbol_in NAME(bfd_elf,swap_symbol_in)
95 #define elf_swap_symbol_out NAME(bfd_elf,swap_symbol_out)
96 #define elf_swap_phdr_in NAME(bfd_elf,swap_phdr_in)
97 #define elf_swap_phdr_out NAME(bfd_elf,swap_phdr_out)
98 #define elf_swap_dyn_in NAME(bfd_elf,swap_dyn_in)
99 #define elf_swap_dyn_out NAME(bfd_elf,swap_dyn_out)
100 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
101 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
102 #define elf_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
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_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
119 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
120 #define elf_link_create_dynamic_sections \
121 NAME(bfd_elf,link_create_dynamic_sections)
122 #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
123 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
124 #define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
125 #define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
126 #define elf_gc_sections NAME(_bfd_elf,gc_sections)
127 #define elf_gc_common_finalize_got_offsets \
128 NAME(_bfd_elf,gc_common_finalize_got_offsets)
129 #define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
130 #define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
131 #define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
134 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
135 #define ELF_R_SYM(X) ELF64_R_SYM(X)
136 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
137 #define ELFCLASS ELFCLASS64
139 #define LOG_FILE_ALIGN 3
142 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
143 #define ELF_R_SYM(X) ELF32_R_SYM(X)
144 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
145 #define ELFCLASS ELFCLASS32
147 #define LOG_FILE_ALIGN 2
150 /* Static functions */
152 static void elf_swap_ehdr_in
153 PARAMS ((bfd
*, const Elf_External_Ehdr
*, Elf_Internal_Ehdr
*));
154 static void elf_swap_ehdr_out
155 PARAMS ((bfd
*, const Elf_Internal_Ehdr
*, Elf_External_Ehdr
*));
156 static void elf_swap_shdr_in
157 PARAMS ((bfd
*, const Elf_External_Shdr
*, Elf_Internal_Shdr
*));
158 static void elf_swap_shdr_out
159 PARAMS ((bfd
*, const Elf_Internal_Shdr
*, Elf_External_Shdr
*));
161 #define elf_stringtab_init _bfd_elf_stringtab_init
163 #define section_from_elf_index bfd_section_from_elf_index
165 static boolean elf_slurp_reloc_table
166 PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
168 static void write_relocs
PARAMS ((bfd
*, asection
*, PTR
));
170 static boolean elf_file_p
PARAMS ((Elf_External_Ehdr
*));
173 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
174 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
175 static char *elf_symbol_flags
PARAMS ((flagword
));
178 /* Structure swapping routines */
180 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
181 can be handled by explicitly specifying 32 bits or "the long type". */
183 #define put_word bfd_h_put_64
184 #define put_signed_word bfd_h_put_signed_64
185 #define get_word bfd_h_get_64
186 #define get_signed_word bfd_h_get_signed_64
189 #define put_word bfd_h_put_32
190 #define put_signed_word bfd_h_put_signed_32
191 #define get_word bfd_h_get_32
192 #define get_signed_word bfd_h_get_signed_32
195 /* Translate an ELF symbol in external format into an ELF symbol in internal
199 elf_swap_symbol_in (abfd
, src
, dst
)
201 const Elf_External_Sym
*src
;
202 Elf_Internal_Sym
*dst
;
204 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
205 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
206 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
207 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
208 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
209 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
212 /* Translate an ELF symbol in internal format into an ELF symbol in external
216 elf_swap_symbol_out (abfd
, src
, cdst
)
218 const Elf_Internal_Sym
*src
;
221 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
222 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
223 put_word (abfd
, src
->st_value
, dst
->st_value
);
224 put_word (abfd
, src
->st_size
, dst
->st_size
);
225 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
226 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
227 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
231 /* Translate an ELF file header in external format into an ELF file header in
235 elf_swap_ehdr_in (abfd
, src
, dst
)
237 const Elf_External_Ehdr
*src
;
238 Elf_Internal_Ehdr
*dst
;
240 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
241 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
242 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
243 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
244 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
245 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
246 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
247 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
248 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
249 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
250 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
251 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
252 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
253 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
256 /* Translate an ELF file header in internal format into an ELF file header in
260 elf_swap_ehdr_out (abfd
, src
, dst
)
262 const Elf_Internal_Ehdr
*src
;
263 Elf_External_Ehdr
*dst
;
265 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
266 /* note that all elements of dst are *arrays of unsigned char* already... */
267 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
268 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
269 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
270 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
271 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
272 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
273 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
274 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
275 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
276 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
277 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
278 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
279 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
283 /* Translate an ELF section header table entry in external format into an
284 ELF section header table entry in internal format. */
287 elf_swap_shdr_in (abfd
, src
, dst
)
289 const Elf_External_Shdr
*src
;
290 Elf_Internal_Shdr
*dst
;
292 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
293 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
294 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
295 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
296 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
297 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
298 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
299 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
300 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
301 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
302 dst
->bfd_section
= NULL
;
303 dst
->contents
= NULL
;
306 /* Translate an ELF section header table entry in internal format into an
307 ELF section header table entry in external format. */
310 elf_swap_shdr_out (abfd
, src
, dst
)
312 const Elf_Internal_Shdr
*src
;
313 Elf_External_Shdr
*dst
;
315 /* note that all elements of dst are *arrays of unsigned char* already... */
316 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
317 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
318 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
319 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
320 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
321 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
322 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
323 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
324 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
325 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
329 /* Translate an ELF program header table entry in external format into an
330 ELF program header table entry in internal format. */
333 elf_swap_phdr_in (abfd
, src
, dst
)
335 const Elf_External_Phdr
*src
;
336 Elf_Internal_Phdr
*dst
;
338 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
339 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
340 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
341 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
342 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
343 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
344 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
345 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
349 elf_swap_phdr_out (abfd
, src
, dst
)
351 const Elf_Internal_Phdr
*src
;
352 Elf_External_Phdr
*dst
;
354 /* note that all elements of dst are *arrays of unsigned char* already... */
355 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
356 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
357 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
358 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
359 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
360 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
361 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
362 put_word (abfd
, src
->p_align
, dst
->p_align
);
365 /* Translate an ELF reloc from external format to internal format. */
367 elf_swap_reloc_in (abfd
, src
, dst
)
369 const Elf_External_Rel
*src
;
370 Elf_Internal_Rel
*dst
;
372 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
373 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
377 elf_swap_reloca_in (abfd
, src
, dst
)
379 const Elf_External_Rela
*src
;
380 Elf_Internal_Rela
*dst
;
382 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
383 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
384 dst
->r_addend
= get_signed_word (abfd
, (bfd_byte
*) src
->r_addend
);
387 /* Translate an ELF reloc from internal format to external format. */
389 elf_swap_reloc_out (abfd
, src
, dst
)
391 const Elf_Internal_Rel
*src
;
392 Elf_External_Rel
*dst
;
394 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
395 put_word (abfd
, src
->r_info
, dst
->r_info
);
399 elf_swap_reloca_out (abfd
, src
, dst
)
401 const Elf_Internal_Rela
*src
;
402 Elf_External_Rela
*dst
;
404 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
405 put_word (abfd
, src
->r_info
, dst
->r_info
);
406 put_signed_word (abfd
, src
->r_addend
, dst
->r_addend
);
410 elf_swap_dyn_in (abfd
, p
, dst
)
413 Elf_Internal_Dyn
*dst
;
415 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
417 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
418 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
422 elf_swap_dyn_out (abfd
, src
, dst
)
424 const Elf_Internal_Dyn
*src
;
425 Elf_External_Dyn
*dst
;
427 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
428 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
431 /* ELF .o/exec file reading */
434 /* Begin processing a given object.
436 First we validate the file by reading in the ELF header and checking
439 static INLINE boolean
441 Elf_External_Ehdr
*x_ehdrp
;
443 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
444 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
445 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
446 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
449 /* Check to see if the file associated with ABFD matches the target vector
452 Note that we may be called several times with the same ABFD, but different
453 target vectors, most of which will not match. We have to avoid leaving
454 any side effects in ABFD, or any data it points to (like tdata), if the
455 file does not match the target vector. */
461 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
462 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
463 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
464 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
465 unsigned int shindex
;
466 char *shstrtab
; /* Internal copy of section header stringtab */
467 struct elf_backend_data
*ebd
;
468 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
469 struct elf_obj_tdata
*new_tdata
= NULL
;
472 /* Read in the ELF header in external format. */
474 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
476 if (bfd_get_error () != bfd_error_system_call
)
477 goto got_wrong_format_error
;
482 /* Now check to see if we have a valid ELF file, and one that BFD can
483 make use of. The magic number must match, the address size ('class')
484 and byte-swapping must match our XVEC entry, and it must have a
485 section header table (FIXME: See comments re sections at top of this
488 if ((elf_file_p (&x_ehdr
) == false) ||
489 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
490 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
491 goto got_wrong_format_error
;
493 /* Check that file's byte order matches xvec's */
494 switch (x_ehdr
.e_ident
[EI_DATA
])
496 case ELFDATA2MSB
: /* Big-endian */
497 if (! bfd_header_big_endian (abfd
))
498 goto got_wrong_format_error
;
500 case ELFDATA2LSB
: /* Little-endian */
501 if (! bfd_header_little_endian (abfd
))
502 goto got_wrong_format_error
;
504 case ELFDATANONE
: /* No data encoding specified */
505 default: /* Unknown data encoding specified */
506 goto got_wrong_format_error
;
509 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
510 the tdata pointer in the bfd. */
512 new_tdata
= ((struct elf_obj_tdata
*)
513 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
514 if (new_tdata
== NULL
)
516 elf_tdata (abfd
) = new_tdata
;
518 /* Now that we know the byte order, swap in the rest of the header */
519 i_ehdrp
= elf_elfheader (abfd
);
520 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
522 elf_debug_file (i_ehdrp
);
525 /* Reject ET_CORE (header indicates core file, not object file) */
526 if (i_ehdrp
->e_type
== ET_CORE
)
527 goto got_wrong_format_error
;
529 /* If there is no section header table, we're hosed. */
530 if (i_ehdrp
->e_shoff
== 0)
531 goto got_wrong_format_error
;
533 /* As a simple sanity check, verify that the what BFD thinks is the
534 size of each section header table entry actually matches the size
535 recorded in the file. */
536 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
537 goto got_wrong_format_error
;
539 ebd
= get_elf_backend_data (abfd
);
541 /* Check that the ELF e_machine field matches what this particular
542 BFD format expects. */
543 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
544 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
545 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
547 const bfd_target
* const *target_ptr
;
549 if (ebd
->elf_machine_code
!= EM_NONE
)
550 goto got_wrong_format_error
;
552 /* This is the generic ELF target. Let it match any ELF target
553 for which we do not have a specific backend. */
554 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
556 struct elf_backend_data
*back
;
558 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
560 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
561 if (back
->elf_machine_code
== i_ehdrp
->e_machine
562 || (back
->elf_machine_alt1
!= 0
563 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
564 || (back
->elf_machine_alt2
!= 0
565 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
567 /* target_ptr is an ELF backend which matches this
568 object file, so reject the generic ELF target. */
569 goto got_wrong_format_error
;
574 if (i_ehdrp
->e_type
== ET_EXEC
)
575 abfd
->flags
|= EXEC_P
;
576 else if (i_ehdrp
->e_type
== ET_DYN
)
577 abfd
->flags
|= DYNAMIC
;
579 if (i_ehdrp
->e_phnum
> 0)
580 abfd
->flags
|= D_PAGED
;
582 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
584 /* It's OK if this fails for the generic target. */
585 if (ebd
->elf_machine_code
!= EM_NONE
)
589 /* Remember the entry point specified in the ELF file header. */
590 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
592 /* Allocate space for a copy of the section header table in
593 internal form, seek to the section header table in the file,
594 read it in, and convert it to internal form. */
595 i_shdrp
= ((Elf_Internal_Shdr
*)
596 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
597 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
599 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
600 if (!i_shdrp
|| !elf_elfsections (abfd
))
602 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
604 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
606 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
608 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
609 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
611 /* If the section is loaded, but not page aligned, clear
613 if ((i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
614 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
615 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
618 abfd
->flags
&= ~D_PAGED
;
620 if (i_ehdrp
->e_shstrndx
)
622 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
626 /* Read in the program headers. */
627 if (i_ehdrp
->e_phnum
== 0)
628 elf_tdata (abfd
)->phdr
= NULL
;
631 Elf_Internal_Phdr
*i_phdr
;
634 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
637 * sizeof (Elf_Internal_Phdr
))));
638 if (elf_tdata (abfd
)->phdr
== NULL
)
640 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
642 i_phdr
= elf_tdata (abfd
)->phdr
;
643 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
645 Elf_External_Phdr x_phdr
;
647 if (bfd_read ((PTR
) &x_phdr
, sizeof x_phdr
, 1, abfd
)
650 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
654 /* Read in the string table containing the names of the sections. We
655 will need the base pointer to this table later. */
656 /* We read this inline now, so that we don't have to go through
657 bfd_section_from_shdr with it (since this particular strtab is
658 used to find all of the ELF section names.) */
660 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
664 /* Once all of the section headers have been read and converted, we
665 can start processing them. Note that the first section header is
666 a dummy placeholder entry, so we ignore it. */
668 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
670 if (! bfd_section_from_shdr (abfd
, shindex
))
674 /* Let the backend double check the format and override global
676 if (ebd
->elf_backend_object_p
)
678 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
679 goto got_wrong_format_error
;
682 /* If we have created any reloc sections that are associated with
683 debugging sections, mark the reloc sections as debugging as well. */
684 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
686 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
687 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
688 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
690 unsigned long targ_index
;
693 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
694 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
696 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
697 s
->flags
|= SEC_DEBUGGING
;
703 got_wrong_format_error
:
704 bfd_set_error (bfd_error_wrong_format
);
706 if (new_tdata
!= NULL
707 && new_tdata
->elf_sect_ptr
!= NULL
)
708 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
710 bfd_release (abfd
, i_shdrp
);
711 if (new_tdata
!= NULL
)
712 bfd_release (abfd
, new_tdata
);
713 elf_tdata (abfd
) = preserved_tdata
;
717 /* ELF .o/exec file writing */
719 /* Write out the relocs. */
722 write_relocs (abfd
, sec
, data
)
727 boolean
*failedp
= (boolean
*) data
;
728 Elf_Internal_Shdr
*rela_hdr
;
729 Elf_External_Rela
*outbound_relocas
;
730 Elf_External_Rel
*outbound_relocs
;
733 asymbol
*last_sym
= 0;
734 int last_sym_idx
= 0;
736 /* If we have already failed, don't do anything. */
740 if ((sec
->flags
& SEC_RELOC
) == 0)
743 /* The linker backend writes the relocs out itself, and sets the
744 reloc_count field to zero to inhibit writing them here. Also,
745 sometimes the SEC_RELOC flag gets set even when there aren't any
747 if (sec
->reloc_count
== 0)
750 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
752 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
753 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
754 if (rela_hdr
->contents
== NULL
)
760 /* Figure out whether the relocations are RELA or REL relocations. */
761 if (rela_hdr
->sh_type
== SHT_RELA
)
763 else if (rela_hdr
->sh_type
== SHT_REL
)
766 /* Every relocation section should be either an SHT_RELA or an
770 /* orelocation has the data, reloc_count has the count... */
773 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
775 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
777 Elf_Internal_Rela dst_rela
;
778 Elf_External_Rela
*src_rela
;
783 ptr
= sec
->orelocation
[idx
];
784 src_rela
= outbound_relocas
+ idx
;
786 /* The address of an ELF reloc is section relative for an object
787 file, and absolute for an executable file or shared library.
788 The address of a BFD reloc is always section relative. */
789 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
790 dst_rela
.r_offset
= ptr
->address
;
792 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
794 sym
= *ptr
->sym_ptr_ptr
;
797 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
802 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
811 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
812 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
813 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
819 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
821 dst_rela
.r_addend
= ptr
->addend
;
822 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
826 /* REL relocations */
828 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
830 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
832 Elf_Internal_Rel dst_rel
;
833 Elf_External_Rel
*src_rel
;
838 ptr
= sec
->orelocation
[idx
];
839 sym
= *ptr
->sym_ptr_ptr
;
840 src_rel
= outbound_relocs
+ idx
;
842 /* The address of an ELF reloc is section relative for an object
843 file, and absolute for an executable file or shared library.
844 The address of a BFD reloc is always section relative. */
845 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
846 dst_rel
.r_offset
= ptr
->address
;
848 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
855 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
864 if ((*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
865 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
871 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
873 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
878 /* Write out the program headers. */
881 elf_write_out_phdrs (abfd
, phdr
, count
)
883 const Elf_Internal_Phdr
*phdr
;
888 Elf_External_Phdr extphdr
;
889 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
890 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
891 != sizeof (Elf_External_Phdr
))
898 /* Write out the section headers and the ELF file header. */
901 elf_write_shdrs_and_ehdr (abfd
)
904 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
905 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
906 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
907 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
910 i_ehdrp
= elf_elfheader (abfd
);
911 i_shdrp
= elf_elfsections (abfd
);
913 /* swap the header before spitting it out... */
916 elf_debug_file (i_ehdrp
);
918 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
919 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
920 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
924 /* at this point we've concocted all the ELF sections... */
925 x_shdrp
= (Elf_External_Shdr
*)
926 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
930 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
933 elf_debug_section (count
, i_shdrp
[count
]);
935 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
937 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
938 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
939 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
942 /* need to dump the string table too... */
948 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
950 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
953 Elf_Internal_Shdr
*hdr
;
954 Elf_Internal_Shdr
*verhdr
;
955 unsigned long symcount
; /* Number of external ELF symbols */
956 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
957 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
958 Elf_Internal_Sym i_sym
;
959 Elf_External_Sym
*x_symp
= NULL
;
960 Elf_External_Versym
*x_versymp
= NULL
;
962 /* Read each raw ELF symbol, converting from external ELF form to
963 internal ELF form, and then using the information to create a
964 canonical bfd symbol table entry.
966 Note that we allocate the initial bfd canonical symbol buffer
967 based on a one-to-one mapping of the ELF symbols to canonical
968 symbols. We actually use all the ELF symbols, so there will be no
969 space left over at the end. When we have all the symbols, we
970 build the caller's pointer vector. */
974 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
979 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
980 if (elf_dynversym (abfd
) == 0)
983 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
984 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
985 && elf_tdata (abfd
)->verdef
== NULL
)
986 || (elf_tdata (abfd
)->dynverref_section
!= 0
987 && elf_tdata (abfd
)->verref
== NULL
))
989 if (! _bfd_elf_slurp_version_tables (abfd
))
994 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
997 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1000 sym
= symbase
= NULL
;
1005 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
1008 symbase
= ((elf_symbol_type
*)
1009 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
1010 if (symbase
== (elf_symbol_type
*) NULL
)
1014 /* Temporarily allocate room for the raw ELF symbols. */
1015 x_symp
= ((Elf_External_Sym
*)
1016 bfd_malloc (symcount
* sizeof (Elf_External_Sym
)));
1017 if (x_symp
== NULL
&& symcount
!= 0)
1020 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
1021 != symcount
* sizeof (Elf_External_Sym
))
1024 /* Read the raw ELF version symbol information. */
1027 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1029 (*_bfd_error_handler
)
1030 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1032 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1035 /* Slurp in the symbols without the version information,
1036 since that is more helpful than just quitting. */
1042 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1045 x_versymp
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1046 if (x_versymp
== NULL
&& verhdr
->sh_size
!= 0)
1049 if (bfd_read ((PTR
) x_versymp
, 1, verhdr
->sh_size
, abfd
)
1054 /* Skip first symbol, which is a null dummy. */
1055 for (i
= 1; i
< symcount
; i
++)
1057 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
1058 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
1059 #ifdef ELF_KEEP_EXTSYM
1060 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
1062 sym
->symbol
.the_bfd
= abfd
;
1064 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
1068 sym
->symbol
.value
= i_sym
.st_value
;
1070 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
1072 sym
->symbol
.section
= section_from_elf_index (abfd
,
1074 if (sym
->symbol
.section
== NULL
)
1076 /* This symbol is in a section for which we did not
1077 create a BFD section. Just use bfd_abs_section,
1078 although it is wrong. FIXME. */
1079 sym
->symbol
.section
= bfd_abs_section_ptr
;
1082 else if (i_sym
.st_shndx
== SHN_ABS
)
1084 sym
->symbol
.section
= bfd_abs_section_ptr
;
1086 else if (i_sym
.st_shndx
== SHN_COMMON
)
1088 sym
->symbol
.section
= bfd_com_section_ptr
;
1089 /* Elf puts the alignment into the `value' field, and
1090 the size into the `size' field. BFD wants to see the
1091 size in the value field, and doesn't care (at the
1092 moment) about the alignment. */
1093 sym
->symbol
.value
= i_sym
.st_size
;
1095 else if (i_sym
.st_shndx
== SHN_UNDEF
)
1097 sym
->symbol
.section
= bfd_und_section_ptr
;
1100 sym
->symbol
.section
= bfd_abs_section_ptr
;
1102 /* If this is a relocateable file, then the symbol value is
1103 already section relative. */
1104 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1105 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1107 switch (ELF_ST_BIND (i_sym
.st_info
))
1110 sym
->symbol
.flags
|= BSF_LOCAL
;
1113 if (i_sym
.st_shndx
!= SHN_UNDEF
1114 && i_sym
.st_shndx
!= SHN_COMMON
)
1115 sym
->symbol
.flags
|= BSF_GLOBAL
;
1118 sym
->symbol
.flags
|= BSF_WEAK
;
1122 switch (ELF_ST_TYPE (i_sym
.st_info
))
1125 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1128 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1131 sym
->symbol
.flags
|= BSF_FUNCTION
;
1134 sym
->symbol
.flags
|= BSF_OBJECT
;
1139 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1141 if (x_versymp
!= NULL
)
1143 Elf_Internal_Versym iversym
;
1145 _bfd_elf_swap_versym_in (abfd
, x_versymp
+ i
, &iversym
);
1146 sym
->version
= iversym
.vs_vers
;
1149 /* Do some backend-specific processing on this symbol. */
1151 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1152 if (ebd
->elf_backend_symbol_processing
)
1153 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1160 /* Do some backend-specific processing on this symbol table. */
1162 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1163 if (ebd
->elf_backend_symbol_table_processing
)
1164 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1167 /* We rely on the zalloc to clear out the final symbol entry. */
1169 symcount
= sym
- symbase
;
1171 /* Fill in the user's symbol pointer vector if needed. */
1179 *symptrs
++ = &sym
->symbol
;
1182 *symptrs
= 0; /* Final null pointer */
1185 if (x_versymp
!= NULL
)
1191 if (x_versymp
!= NULL
)
1198 /* Read in and swap the external relocs. */
1201 elf_slurp_reloc_table (abfd
, asect
, symbols
, dynamic
)
1207 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1208 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1209 Elf_Internal_Shdr
*rel_hdr
;
1210 bfd_size_type reloc_count
;
1211 PTR allocated
= NULL
;
1212 bfd_byte
*native_relocs
;
1218 if (asect
->relocation
!= NULL
)
1223 if ((asect
->flags
& SEC_RELOC
) == 0
1224 || asect
->reloc_count
== 0)
1227 rel_hdr
= &d
->rel_hdr
;
1228 reloc_count
= asect
->reloc_count
;
1230 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1231 && reloc_count
== rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
);
1235 if (asect
->_raw_size
== 0)
1238 rel_hdr
= &d
->this_hdr
;
1239 reloc_count
= rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
;
1242 allocated
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1243 if (allocated
== NULL
)
1246 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1247 || (bfd_read (allocated
, 1, rel_hdr
->sh_size
, abfd
)
1248 != rel_hdr
->sh_size
))
1251 native_relocs
= (bfd_byte
*) allocated
;
1253 relents
= (arelent
*) bfd_alloc (abfd
, reloc_count
* sizeof (arelent
));
1254 if (relents
== NULL
)
1257 entsize
= rel_hdr
->sh_entsize
;
1258 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1259 || entsize
== sizeof (Elf_External_Rela
));
1261 for (i
= 0, relent
= relents
;
1263 i
++, relent
++, native_relocs
+= entsize
)
1265 Elf_Internal_Rela rela
;
1266 Elf_Internal_Rel rel
;
1268 if (entsize
== sizeof (Elf_External_Rela
))
1269 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
1272 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
1273 rela
.r_offset
= rel
.r_offset
;
1274 rela
.r_info
= rel
.r_info
;
1278 /* The address of an ELF reloc is section relative for an object
1279 file, and absolute for an executable file or shared library.
1280 The address of a normal BFD reloc is always section relative,
1281 and the address of a dynamic reloc is absolute.. */
1282 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1283 relent
->address
= rela
.r_offset
;
1285 relent
->address
= rela
.r_offset
- asect
->vma
;
1287 if (ELF_R_SYM (rela
.r_info
) == 0)
1288 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1293 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1296 /* Canonicalize ELF section symbols. FIXME: Why? */
1297 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1298 relent
->sym_ptr_ptr
= ps
;
1300 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1303 relent
->addend
= rela
.r_addend
;
1305 if (entsize
== sizeof (Elf_External_Rela
))
1306 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1308 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
1311 asect
->relocation
= relents
;
1313 if (allocated
!= NULL
)
1319 if (allocated
!= NULL
)
1326 elf_debug_section (num
, hdr
)
1328 Elf_Internal_Shdr
*hdr
;
1330 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1331 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1334 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1335 (long) hdr
->sh_name
,
1336 (long) hdr
->sh_type
,
1337 (long) hdr
->sh_flags
);
1339 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1340 (long) hdr
->sh_addr
,
1341 (long) hdr
->sh_offset
,
1342 (long) hdr
->sh_size
);
1344 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1345 (long) hdr
->sh_link
,
1346 (long) hdr
->sh_info
,
1347 (long) hdr
->sh_addralign
);
1348 fprintf (stderr
, "sh_entsize = %ld\n",
1349 (long) hdr
->sh_entsize
);
1354 elf_debug_file (ehdrp
)
1355 Elf_Internal_Ehdr
*ehdrp
;
1357 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1358 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1359 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1360 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1361 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1362 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1363 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1367 elf_symbol_flags (flags
)
1370 static char buffer
[1024];
1373 if (flags
& BSF_LOCAL
)
1374 strcat (buffer
, " local");
1376 if (flags
& BSF_GLOBAL
)
1377 strcat (buffer
, " global");
1379 if (flags
& BSF_DEBUGGING
)
1380 strcat (buffer
, " debug");
1382 if (flags
& BSF_FUNCTION
)
1383 strcat (buffer
, " function");
1385 if (flags
& BSF_KEEP
)
1386 strcat (buffer
, " keep");
1388 if (flags
& BSF_KEEP_G
)
1389 strcat (buffer
, " keep_g");
1391 if (flags
& BSF_WEAK
)
1392 strcat (buffer
, " weak");
1394 if (flags
& BSF_SECTION_SYM
)
1395 strcat (buffer
, " section-sym");
1397 if (flags
& BSF_OLD_COMMON
)
1398 strcat (buffer
, " old-common");
1400 if (flags
& BSF_NOT_AT_END
)
1401 strcat (buffer
, " not-at-end");
1403 if (flags
& BSF_CONSTRUCTOR
)
1404 strcat (buffer
, " constructor");
1406 if (flags
& BSF_WARNING
)
1407 strcat (buffer
, " warning");
1409 if (flags
& BSF_INDIRECT
)
1410 strcat (buffer
, " indirect");
1412 if (flags
& BSF_FILE
)
1413 strcat (buffer
, " file");
1415 if (flags
& DYNAMIC
)
1416 strcat (buffer
, " dynamic");
1418 if (flags
& ~(BSF_LOCAL
1433 strcat (buffer
, " unknown-bits");
1439 #include "elfcore.h"
1440 #include "elflink.h"
1442 /* Size-dependent data and functions. */
1443 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1444 sizeof (Elf_External_Ehdr
),
1445 sizeof (Elf_External_Phdr
),
1446 sizeof (Elf_External_Shdr
),
1447 sizeof (Elf_External_Rel
),
1448 sizeof (Elf_External_Rela
),
1449 sizeof (Elf_External_Sym
),
1450 sizeof (Elf_External_Dyn
),
1451 sizeof (Elf_External_Note
),
1453 ARCH_SIZE
, FILE_ALIGN
,
1454 ELFCLASS
, EV_CURRENT
,
1455 elf_write_out_phdrs
,
1456 elf_write_shdrs_and_ehdr
,
1458 elf_swap_symbol_out
,
1459 elf_slurp_reloc_table
,
1460 elf_slurp_symbol_table
,