1 /* ELF executable support for BFD.
2 Copyright 1991, 92, 93, 94, 95, 96, 97, 98, 1999 Free Software
5 Written by Fred Fish @ Cygnus Support, from information published
6 in "UNIX System V Release 4, Programmers Guide: ANSI C and
7 Programming Support Tools". Sufficient support for gdb.
9 Rewritten by Mark Eichin @ Cygnus Support, from information
10 published in "System V Application Binary Interface", chapters 4
11 and 5, as well as the various "Processor Supplement" documents
12 derived from it. Added support for assembler and other object file
13 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
14 Meissner (Open Software Foundation), and Peter Hoogenboom (University
15 of Utah) to finish and extend this.
17 This file is part of BFD, the Binary File Descriptor library.
19 This program is free software; you can redistribute it and/or modify
20 it under the terms of the GNU General Public License as published by
21 the Free Software Foundation; either version 2 of the License, or
22 (at your option) any later version.
24 This program is distributed in the hope that it will be useful,
25 but WITHOUT ANY WARRANTY; without even the implied warranty of
26 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 GNU General Public License for more details.
29 You should have received a copy of the GNU General Public License
30 along with this program; if not, write to the Free Software
31 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 /* Problems and other issues to resolve.
35 (1) BFD expects there to be some fixed number of "sections" in
36 the object file. I.E. there is a "section_count" variable in the
37 bfd structure which contains the number of sections. However, ELF
38 supports multiple "views" of a file. In particular, with current
39 implementations, executable files typically have two tables, a
40 program header table and a section header table, both of which
41 partition the executable.
43 In ELF-speak, the "linking view" of the file uses the section header
44 table to access "sections" within the file, and the "execution view"
45 uses the program header table to access "segments" within the file.
46 "Segments" typically may contain all the data from one or more
49 Note that the section header table is optional in ELF executables,
50 but it is this information that is most useful to gdb. If the
51 section header table is missing, then gdb should probably try
52 to make do with the program header table. (FIXME)
54 (2) The code in this file is compiled twice, once in 32-bit mode and
55 once in 64-bit mode. More of it should be made size-independent
58 (3) ELF section symbols are handled rather sloppily now. This should
59 be cleaned up, and ELF section symbols reconciled with BFD section
62 (4) We need a published spec for 64-bit ELF. We've got some stuff here
63 that we're using for SPARC V9 64-bit chips, but don't assume that
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_slurp_symbol_table NAME(bfd_elf,slurp_symbol_table)
104 #define elf_get_symtab NAME(bfd_elf,get_symtab)
105 #define elf_canonicalize_dynamic_symtab \
106 NAME(bfd_elf,canonicalize_dynamic_symtab)
107 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
108 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
109 #define elf_get_lineno NAME(bfd_elf,get_lineno)
110 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
111 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
112 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
113 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
114 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
115 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
116 #define elf_find_section NAME(bfd_elf,find_section)
117 #define elf_bfd_link_add_symbols NAME(bfd_elf,bfd_link_add_symbols)
118 #define elf_add_dynamic_entry NAME(bfd_elf,add_dynamic_entry)
119 #define elf_write_shdrs_and_ehdr NAME(bfd_elf,write_shdrs_and_ehdr)
120 #define elf_write_out_phdrs NAME(bfd_elf,write_out_phdrs)
121 #define elf_link_create_dynamic_sections \
122 NAME(bfd_elf,link_create_dynamic_sections)
123 #define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
124 #define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
125 #define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
126 #define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
127 #define elf_gc_sections NAME(_bfd_elf,gc_sections)
128 #define elf_gc_common_finalize_got_offsets \
129 NAME(_bfd_elf,gc_common_finalize_got_offsets)
130 #define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
131 #define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
132 #define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
133 #define elf_link_record_local_dynamic_symbol \
134 NAME(_bfd_elf,link_record_local_dynamic_symbol)
137 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
138 #define ELF_R_SYM(X) ELF64_R_SYM(X)
139 #define ELF_R_TYPE(X) ELF64_R_TYPE(X)
140 #define ELFCLASS ELFCLASS64
142 #define LOG_FILE_ALIGN 3
145 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
146 #define ELF_R_SYM(X) ELF32_R_SYM(X)
147 #define ELF_R_TYPE(X) ELF32_R_TYPE(X)
148 #define ELFCLASS ELFCLASS32
150 #define LOG_FILE_ALIGN 2
153 /* Static functions */
155 static void elf_swap_ehdr_in
156 PARAMS ((bfd
*, const Elf_External_Ehdr
*, Elf_Internal_Ehdr
*));
157 static void elf_swap_ehdr_out
158 PARAMS ((bfd
*, const Elf_Internal_Ehdr
*, Elf_External_Ehdr
*));
159 static void elf_swap_shdr_in
160 PARAMS ((bfd
*, const Elf_External_Shdr
*, Elf_Internal_Shdr
*));
161 static void elf_swap_shdr_out
162 PARAMS ((bfd
*, const Elf_Internal_Shdr
*, Elf_External_Shdr
*));
164 #define elf_stringtab_init _bfd_elf_stringtab_init
166 #define section_from_elf_index bfd_section_from_elf_index
168 static boolean elf_slurp_reloc_table_from_section
169 PARAMS ((bfd
*, asection
*, Elf_Internal_Shdr
*, bfd_size_type
,
170 arelent
*, asymbol
**, boolean
));
171 static boolean elf_slurp_reloc_table
172 PARAMS ((bfd
*, asection
*, asymbol
**, boolean
));
174 static void write_relocs
PARAMS ((bfd
*, asection
*, PTR
));
176 static boolean elf_file_p
PARAMS ((Elf_External_Ehdr
*));
179 static void elf_debug_section
PARAMS ((int, Elf_Internal_Shdr
*));
180 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
181 static char *elf_symbol_flags
PARAMS ((flagword
));
184 /* Structure swapping routines */
186 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
187 can be handled by explicitly specifying 32 bits or "the long type". */
189 #define put_word bfd_h_put_64
190 #define put_signed_word bfd_h_put_signed_64
191 #define get_word bfd_h_get_64
192 #define get_signed_word bfd_h_get_signed_64
195 #define put_word bfd_h_put_32
196 #define put_signed_word bfd_h_put_signed_32
197 #define get_word bfd_h_get_32
198 #define get_signed_word bfd_h_get_signed_32
201 /* Translate an ELF symbol in external format into an ELF symbol in internal
205 elf_swap_symbol_in (abfd
, src
, dst
)
207 const Elf_External_Sym
*src
;
208 Elf_Internal_Sym
*dst
;
210 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
211 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
212 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
213 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
214 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
215 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
218 /* Translate an ELF symbol in internal format into an ELF symbol in external
222 elf_swap_symbol_out (abfd
, src
, cdst
)
224 const Elf_Internal_Sym
*src
;
227 Elf_External_Sym
*dst
= (Elf_External_Sym
*) cdst
;
228 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
229 put_word (abfd
, src
->st_value
, dst
->st_value
);
230 put_word (abfd
, src
->st_size
, dst
->st_size
);
231 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
232 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
233 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
237 /* Translate an ELF file header in external format into an ELF file header in
241 elf_swap_ehdr_in (abfd
, src
, dst
)
243 const Elf_External_Ehdr
*src
;
244 Elf_Internal_Ehdr
*dst
;
246 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
247 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
248 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
249 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
250 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
251 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
252 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
253 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
254 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
255 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
256 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
257 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
258 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
259 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
262 /* Translate an ELF file header in internal format into an ELF file header in
266 elf_swap_ehdr_out (abfd
, src
, dst
)
268 const Elf_Internal_Ehdr
*src
;
269 Elf_External_Ehdr
*dst
;
271 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
272 /* note that all elements of dst are *arrays of unsigned char* already... */
273 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
274 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
275 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
276 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
277 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
278 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
279 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
280 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
281 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
282 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
283 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
284 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
285 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
289 /* Translate an ELF section header table entry in external format into an
290 ELF section header table entry in internal format. */
293 elf_swap_shdr_in (abfd
, src
, dst
)
295 const Elf_External_Shdr
*src
;
296 Elf_Internal_Shdr
*dst
;
298 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
299 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
300 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
301 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
302 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
303 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
304 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
305 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
306 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
307 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
308 dst
->bfd_section
= NULL
;
309 dst
->contents
= NULL
;
312 /* Translate an ELF section header table entry in internal format into an
313 ELF section header table entry in external format. */
316 elf_swap_shdr_out (abfd
, src
, dst
)
318 const Elf_Internal_Shdr
*src
;
319 Elf_External_Shdr
*dst
;
321 /* note that all elements of dst are *arrays of unsigned char* already... */
322 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
323 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
324 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
325 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
326 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
327 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
328 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
329 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
330 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
331 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
335 /* Translate an ELF program header table entry in external format into an
336 ELF program header table entry in internal format. */
339 elf_swap_phdr_in (abfd
, src
, dst
)
341 const Elf_External_Phdr
*src
;
342 Elf_Internal_Phdr
*dst
;
344 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
345 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
346 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
347 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
348 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
349 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
350 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
351 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
355 elf_swap_phdr_out (abfd
, src
, dst
)
357 const Elf_Internal_Phdr
*src
;
358 Elf_External_Phdr
*dst
;
360 /* note that all elements of dst are *arrays of unsigned char* already... */
361 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
362 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
363 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
364 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
365 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
366 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
367 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
368 put_word (abfd
, src
->p_align
, dst
->p_align
);
371 /* Translate an ELF reloc from external format to internal format. */
373 elf_swap_reloc_in (abfd
, src
, dst
)
375 const Elf_External_Rel
*src
;
376 Elf_Internal_Rel
*dst
;
378 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
379 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
383 elf_swap_reloca_in (abfd
, src
, dst
)
385 const Elf_External_Rela
*src
;
386 Elf_Internal_Rela
*dst
;
388 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
389 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
390 dst
->r_addend
= get_signed_word (abfd
, (bfd_byte
*) src
->r_addend
);
393 /* Translate an ELF reloc from internal format to external format. */
395 elf_swap_reloc_out (abfd
, src
, dst
)
397 const Elf_Internal_Rel
*src
;
398 Elf_External_Rel
*dst
;
400 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
401 put_word (abfd
, src
->r_info
, dst
->r_info
);
405 elf_swap_reloca_out (abfd
, src
, dst
)
407 const Elf_Internal_Rela
*src
;
408 Elf_External_Rela
*dst
;
410 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
411 put_word (abfd
, src
->r_info
, dst
->r_info
);
412 put_signed_word (abfd
, src
->r_addend
, dst
->r_addend
);
416 elf_swap_dyn_in (abfd
, p
, dst
)
419 Elf_Internal_Dyn
*dst
;
421 const Elf_External_Dyn
*src
= (const Elf_External_Dyn
*) p
;
423 dst
->d_tag
= get_word (abfd
, src
->d_tag
);
424 dst
->d_un
.d_val
= get_word (abfd
, src
->d_un
.d_val
);
428 elf_swap_dyn_out (abfd
, src
, p
)
430 const Elf_Internal_Dyn
*src
;
433 Elf_External_Dyn
*dst
= (Elf_External_Dyn
*) p
;
435 put_word (abfd
, src
->d_tag
, dst
->d_tag
);
436 put_word (abfd
, src
->d_un
.d_val
, dst
->d_un
.d_val
);
439 /* ELF .o/exec file reading */
442 /* Begin processing a given object.
444 First we validate the file by reading in the ELF header and checking
447 static INLINE boolean
449 Elf_External_Ehdr
*x_ehdrp
;
451 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
452 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
453 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
454 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
457 /* Check to see if the file associated with ABFD matches the target vector
460 Note that we may be called several times with the same ABFD, but different
461 target vectors, most of which will not match. We have to avoid leaving
462 any side effects in ABFD, or any data it points to (like tdata), if the
463 file does not match the target vector. */
469 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
470 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
471 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
472 Elf_Internal_Shdr
*i_shdrp
= NULL
; /* Section header table, internal form */
473 unsigned int shindex
;
474 char *shstrtab
; /* Internal copy of section header stringtab */
475 struct elf_backend_data
*ebd
;
476 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
477 struct elf_obj_tdata
*new_tdata
= NULL
;
480 /* Read in the ELF header in external format. */
482 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
484 if (bfd_get_error () != bfd_error_system_call
)
485 goto got_wrong_format_error
;
490 /* Now check to see if we have a valid ELF file, and one that BFD can
491 make use of. The magic number must match, the address size ('class')
492 and byte-swapping must match our XVEC entry, and it must have a
493 section header table (FIXME: See comments re sections at top of this
496 if ((elf_file_p (&x_ehdr
) == false) ||
497 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
498 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
499 goto got_wrong_format_error
;
501 /* Check that file's byte order matches xvec's */
502 switch (x_ehdr
.e_ident
[EI_DATA
])
504 case ELFDATA2MSB
: /* Big-endian */
505 if (! bfd_header_big_endian (abfd
))
506 goto got_wrong_format_error
;
508 case ELFDATA2LSB
: /* Little-endian */
509 if (! bfd_header_little_endian (abfd
))
510 goto got_wrong_format_error
;
512 case ELFDATANONE
: /* No data encoding specified */
513 default: /* Unknown data encoding specified */
514 goto got_wrong_format_error
;
517 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
518 the tdata pointer in the bfd. */
520 new_tdata
= ((struct elf_obj_tdata
*)
521 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
)));
522 if (new_tdata
== NULL
)
524 elf_tdata (abfd
) = new_tdata
;
526 /* Now that we know the byte order, swap in the rest of the header */
527 i_ehdrp
= elf_elfheader (abfd
);
528 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
530 elf_debug_file (i_ehdrp
);
533 /* Reject ET_CORE (header indicates core file, not object file) */
534 if (i_ehdrp
->e_type
== ET_CORE
)
535 goto got_wrong_format_error
;
537 /* If there is no section header table, we're hosed. */
538 if (i_ehdrp
->e_shoff
== 0)
539 goto got_wrong_format_error
;
541 /* As a simple sanity check, verify that the what BFD thinks is the
542 size of each section header table entry actually matches the size
543 recorded in the file. */
544 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
545 goto got_wrong_format_error
;
547 ebd
= get_elf_backend_data (abfd
);
549 /* Check that the ELF e_machine field matches what this particular
550 BFD format expects. */
551 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
552 && (ebd
->elf_machine_alt1
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt1
)
553 && (ebd
->elf_machine_alt2
== 0 || i_ehdrp
->e_machine
!= ebd
->elf_machine_alt2
))
555 const bfd_target
* const *target_ptr
;
557 if (ebd
->elf_machine_code
!= EM_NONE
)
558 goto got_wrong_format_error
;
560 /* This is the generic ELF target. Let it match any ELF target
561 for which we do not have a specific backend. */
562 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
564 struct elf_backend_data
*back
;
566 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
568 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
569 if (back
->elf_machine_code
== i_ehdrp
->e_machine
570 || (back
->elf_machine_alt1
!= 0
571 && back
->elf_machine_alt1
== i_ehdrp
->e_machine
)
572 || (back
->elf_machine_alt2
!= 0
573 && back
->elf_machine_alt2
== i_ehdrp
->e_machine
))
575 /* target_ptr is an ELF backend which matches this
576 object file, so reject the generic ELF target. */
577 goto got_wrong_format_error
;
582 if (i_ehdrp
->e_type
== ET_EXEC
)
583 abfd
->flags
|= EXEC_P
;
584 else if (i_ehdrp
->e_type
== ET_DYN
)
585 abfd
->flags
|= DYNAMIC
;
587 if (i_ehdrp
->e_phnum
> 0)
588 abfd
->flags
|= D_PAGED
;
590 if (! bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0))
592 /* It's OK if this fails for the generic target. */
593 if (ebd
->elf_machine_code
!= EM_NONE
)
597 /* Remember the entry point specified in the ELF file header. */
598 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
600 /* Allocate space for a copy of the section header table in
601 internal form, seek to the section header table in the file,
602 read it in, and convert it to internal form. */
603 i_shdrp
= ((Elf_Internal_Shdr
*)
604 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
));
605 elf_elfsections (abfd
) = ((Elf_Internal_Shdr
**)
607 sizeof (i_shdrp
) * i_ehdrp
->e_shnum
));
608 if (!i_shdrp
|| !elf_elfsections (abfd
))
610 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) != 0)
612 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
614 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
616 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
617 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
619 /* If the section is loaded, but not page aligned, clear
621 if ((i_shdrp
[shindex
].sh_flags
& SHF_ALLOC
) != 0
622 && i_shdrp
[shindex
].sh_type
!= SHT_NOBITS
623 && (((i_shdrp
[shindex
].sh_addr
- i_shdrp
[shindex
].sh_offset
)
626 abfd
->flags
&= ~D_PAGED
;
628 if (i_ehdrp
->e_shstrndx
)
630 if (! bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
))
634 /* Read in the program headers. */
635 if (i_ehdrp
->e_phnum
== 0)
636 elf_tdata (abfd
)->phdr
= NULL
;
639 Elf_Internal_Phdr
*i_phdr
;
642 elf_tdata (abfd
)->phdr
= ((Elf_Internal_Phdr
*)
645 * sizeof (Elf_Internal_Phdr
))));
646 if (elf_tdata (abfd
)->phdr
== NULL
)
648 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) != 0)
650 i_phdr
= elf_tdata (abfd
)->phdr
;
651 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
653 Elf_External_Phdr x_phdr
;
655 if (bfd_read ((PTR
) &x_phdr
, sizeof x_phdr
, 1, abfd
)
658 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdr
);
662 /* Read in the string table containing the names of the sections. We
663 will need the base pointer to this table later. */
664 /* We read this inline now, so that we don't have to go through
665 bfd_section_from_shdr with it (since this particular strtab is
666 used to find all of the ELF section names.) */
668 shstrtab
= bfd_elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
672 /* Once all of the section headers have been read and converted, we
673 can start processing them. Note that the first section header is
674 a dummy placeholder entry, so we ignore it. */
676 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
678 if (! bfd_section_from_shdr (abfd
, shindex
))
682 /* Let the backend double check the format and override global
684 if (ebd
->elf_backend_object_p
)
686 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
687 goto got_wrong_format_error
;
690 /* If we have created any reloc sections that are associated with
691 debugging sections, mark the reloc sections as debugging as well. */
692 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
694 if ((elf_section_data (s
)->this_hdr
.sh_type
== SHT_REL
695 || elf_section_data (s
)->this_hdr
.sh_type
== SHT_RELA
)
696 && elf_section_data (s
)->this_hdr
.sh_info
> 0)
698 unsigned long targ_index
;
701 targ_index
= elf_section_data (s
)->this_hdr
.sh_info
;
702 targ_sec
= bfd_section_from_elf_index (abfd
, targ_index
);
704 && (targ_sec
->flags
& SEC_DEBUGGING
) != 0)
705 s
->flags
|= SEC_DEBUGGING
;
711 got_wrong_format_error
:
712 bfd_set_error (bfd_error_wrong_format
);
714 if (new_tdata
!= NULL
715 && new_tdata
->elf_sect_ptr
!= NULL
)
716 bfd_release (abfd
, new_tdata
->elf_sect_ptr
);
718 bfd_release (abfd
, i_shdrp
);
719 if (new_tdata
!= NULL
)
720 bfd_release (abfd
, new_tdata
);
721 elf_tdata (abfd
) = preserved_tdata
;
725 /* ELF .o/exec file writing */
727 /* Write out the relocs. */
730 write_relocs (abfd
, sec
, data
)
735 boolean
*failedp
= (boolean
*) data
;
736 Elf_Internal_Shdr
*rela_hdr
;
737 Elf_External_Rela
*outbound_relocas
;
738 Elf_External_Rel
*outbound_relocs
;
741 asymbol
*last_sym
= 0;
742 int last_sym_idx
= 0;
744 /* If we have already failed, don't do anything. */
748 if ((sec
->flags
& SEC_RELOC
) == 0)
751 /* The linker backend writes the relocs out itself, and sets the
752 reloc_count field to zero to inhibit writing them here. Also,
753 sometimes the SEC_RELOC flag gets set even when there aren't any
755 if (sec
->reloc_count
== 0)
758 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
760 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
761 rela_hdr
->contents
= (PTR
) bfd_alloc (abfd
, rela_hdr
->sh_size
);
762 if (rela_hdr
->contents
== NULL
)
768 /* Figure out whether the relocations are RELA or REL relocations. */
769 if (rela_hdr
->sh_type
== SHT_RELA
)
771 else if (rela_hdr
->sh_type
== SHT_REL
)
774 /* Every relocation section should be either an SHT_RELA or an
778 /* orelocation has the data, reloc_count has the count... */
781 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
783 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
785 Elf_Internal_Rela dst_rela
;
786 Elf_External_Rela
*src_rela
;
791 ptr
= sec
->orelocation
[idx
];
792 src_rela
= outbound_relocas
+ idx
;
794 /* The address of an ELF reloc is section relative for an object
795 file, and absolute for an executable file or shared library.
796 The address of a BFD reloc is always section relative. */
797 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
798 dst_rela
.r_offset
= ptr
->address
;
800 dst_rela
.r_offset
= ptr
->address
+ sec
->vma
;
802 sym
= *ptr
->sym_ptr_ptr
;
805 else if (bfd_is_abs_section (sym
->section
) && sym
->value
== 0)
810 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
819 if ((*ptr
->sym_ptr_ptr
)->the_bfd
!= NULL
820 && (*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
821 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
827 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
829 dst_rela
.r_addend
= ptr
->addend
;
830 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
834 /* REL relocations */
836 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
838 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
840 Elf_Internal_Rel dst_rel
;
841 Elf_External_Rel
*src_rel
;
846 ptr
= sec
->orelocation
[idx
];
847 sym
= *ptr
->sym_ptr_ptr
;
848 src_rel
= outbound_relocs
+ idx
;
850 /* The address of an ELF reloc is section relative for an object
851 file, and absolute for an executable file or shared library.
852 The address of a BFD reloc is always section relative. */
853 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0)
854 dst_rel
.r_offset
= ptr
->address
;
856 dst_rel
.r_offset
= ptr
->address
+ sec
->vma
;
863 n
= _bfd_elf_symbol_from_bfd_symbol (abfd
, &sym
);
872 if ((*ptr
->sym_ptr_ptr
)->the_bfd
->xvec
!= abfd
->xvec
873 && ! _bfd_elf_validate_reloc (abfd
, ptr
))
879 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
881 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
886 /* Write out the program headers. */
889 elf_write_out_phdrs (abfd
, phdr
, count
)
891 const Elf_Internal_Phdr
*phdr
;
896 Elf_External_Phdr extphdr
;
897 elf_swap_phdr_out (abfd
, phdr
, &extphdr
);
898 if (bfd_write (&extphdr
, sizeof (Elf_External_Phdr
), 1, abfd
)
899 != sizeof (Elf_External_Phdr
))
906 /* Write out the section headers and the ELF file header. */
909 elf_write_shdrs_and_ehdr (abfd
)
912 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
913 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
914 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
915 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
918 i_ehdrp
= elf_elfheader (abfd
);
919 i_shdrp
= elf_elfsections (abfd
);
921 /* swap the header before spitting it out... */
924 elf_debug_file (i_ehdrp
);
926 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
927 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
928 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
932 /* at this point we've concocted all the ELF sections... */
933 x_shdrp
= (Elf_External_Shdr
*)
934 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
938 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
941 elf_debug_section (count
, i_shdrp
[count
]);
943 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
945 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
946 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
947 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
950 /* need to dump the string table too... */
956 elf_slurp_symbol_table (abfd
, symptrs
, dynamic
)
958 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
961 Elf_Internal_Shdr
*hdr
;
962 Elf_Internal_Shdr
*verhdr
;
963 unsigned long symcount
; /* Number of external ELF symbols */
964 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
965 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
966 Elf_Internal_Sym i_sym
;
967 Elf_External_Sym
*x_symp
= NULL
;
968 Elf_External_Versym
*x_versymp
= NULL
;
970 /* Read each raw ELF symbol, converting from external ELF form to
971 internal ELF form, and then using the information to create a
972 canonical bfd symbol table entry.
974 Note that we allocate the initial bfd canonical symbol buffer
975 based on a one-to-one mapping of the ELF symbols to canonical
976 symbols. We actually use all the ELF symbols, so there will be no
977 space left over at the end. When we have all the symbols, we
978 build the caller's pointer vector. */
982 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
987 hdr
= &elf_tdata (abfd
)->dynsymtab_hdr
;
988 if (elf_dynversym (abfd
) == 0)
991 verhdr
= &elf_tdata (abfd
)->dynversym_hdr
;
992 if ((elf_tdata (abfd
)->dynverdef_section
!= 0
993 && elf_tdata (abfd
)->verdef
== NULL
)
994 || (elf_tdata (abfd
)->dynverref_section
!= 0
995 && elf_tdata (abfd
)->verref
== NULL
))
997 if (! _bfd_elf_slurp_version_tables (abfd
))
1002 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
1005 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1008 sym
= symbase
= NULL
;
1013 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
1016 symbase
= ((elf_symbol_type
*)
1017 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
1018 if (symbase
== (elf_symbol_type
*) NULL
)
1022 /* Temporarily allocate room for the raw ELF symbols. */
1023 x_symp
= ((Elf_External_Sym
*)
1024 bfd_malloc (symcount
* sizeof (Elf_External_Sym
)));
1025 if (x_symp
== NULL
&& symcount
!= 0)
1028 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
1029 != symcount
* sizeof (Elf_External_Sym
))
1032 /* Read the raw ELF version symbol information. */
1035 && verhdr
->sh_size
/ sizeof (Elf_External_Versym
) != symcount
)
1037 (*_bfd_error_handler
)
1038 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1040 (long) (verhdr
->sh_size
/ sizeof (Elf_External_Versym
)),
1043 /* Slurp in the symbols without the version information,
1044 since that is more helpful than just quitting. */
1050 if (bfd_seek (abfd
, verhdr
->sh_offset
, SEEK_SET
) != 0)
1053 x_versymp
= (Elf_External_Versym
*) bfd_malloc (verhdr
->sh_size
);
1054 if (x_versymp
== NULL
&& verhdr
->sh_size
!= 0)
1057 if (bfd_read ((PTR
) x_versymp
, 1, verhdr
->sh_size
, abfd
)
1062 /* Skip first symbol, which is a null dummy. */
1063 for (i
= 1; i
< symcount
; i
++)
1065 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
1066 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
1067 #ifdef ELF_KEEP_EXTSYM
1068 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
1070 sym
->symbol
.the_bfd
= abfd
;
1072 sym
->symbol
.name
= bfd_elf_string_from_elf_section (abfd
,
1076 sym
->symbol
.value
= i_sym
.st_value
;
1078 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERVE
)
1080 sym
->symbol
.section
= section_from_elf_index (abfd
,
1082 if (sym
->symbol
.section
== NULL
)
1084 /* This symbol is in a section for which we did not
1085 create a BFD section. Just use bfd_abs_section,
1086 although it is wrong. FIXME. */
1087 sym
->symbol
.section
= bfd_abs_section_ptr
;
1090 else if (i_sym
.st_shndx
== SHN_ABS
)
1092 sym
->symbol
.section
= bfd_abs_section_ptr
;
1094 else if (i_sym
.st_shndx
== SHN_COMMON
)
1096 sym
->symbol
.section
= bfd_com_section_ptr
;
1097 /* Elf puts the alignment into the `value' field, and
1098 the size into the `size' field. BFD wants to see the
1099 size in the value field, and doesn't care (at the
1100 moment) about the alignment. */
1101 sym
->symbol
.value
= i_sym
.st_size
;
1103 else if (i_sym
.st_shndx
== SHN_UNDEF
)
1105 sym
->symbol
.section
= bfd_und_section_ptr
;
1108 sym
->symbol
.section
= bfd_abs_section_ptr
;
1110 /* If this is a relocateable file, then the symbol value is
1111 already section relative. */
1112 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
1113 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
1115 switch (ELF_ST_BIND (i_sym
.st_info
))
1118 sym
->symbol
.flags
|= BSF_LOCAL
;
1121 if (i_sym
.st_shndx
!= SHN_UNDEF
1122 && i_sym
.st_shndx
!= SHN_COMMON
)
1123 sym
->symbol
.flags
|= BSF_GLOBAL
;
1126 sym
->symbol
.flags
|= BSF_WEAK
;
1130 switch (ELF_ST_TYPE (i_sym
.st_info
))
1133 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
1136 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
1139 sym
->symbol
.flags
|= BSF_FUNCTION
;
1142 sym
->symbol
.flags
|= BSF_OBJECT
;
1147 sym
->symbol
.flags
|= BSF_DYNAMIC
;
1149 if (x_versymp
!= NULL
)
1151 Elf_Internal_Versym iversym
;
1153 _bfd_elf_swap_versym_in (abfd
, x_versymp
+ i
, &iversym
);
1154 sym
->version
= iversym
.vs_vers
;
1157 /* Do some backend-specific processing on this symbol. */
1159 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1160 if (ebd
->elf_backend_symbol_processing
)
1161 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
1168 /* Do some backend-specific processing on this symbol table. */
1170 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
1171 if (ebd
->elf_backend_symbol_table_processing
)
1172 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
1175 /* We rely on the zalloc to clear out the final symbol entry. */
1177 symcount
= sym
- symbase
;
1179 /* Fill in the user's symbol pointer vector if needed. */
1187 *symptrs
++ = &sym
->symbol
;
1190 *symptrs
= 0; /* Final null pointer */
1193 if (x_versymp
!= NULL
)
1199 if (x_versymp
!= NULL
)
1206 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1210 elf_slurp_reloc_table_from_section (abfd
, asect
, rel_hdr
, reloc_count
,
1211 relents
, symbols
, dynamic
)
1214 Elf_Internal_Shdr
*rel_hdr
;
1215 bfd_size_type reloc_count
;
1220 struct elf_backend_data
* const ebd
= get_elf_backend_data (abfd
);
1221 PTR allocated
= NULL
;
1222 bfd_byte
*native_relocs
;
1227 allocated
= (PTR
) bfd_malloc ((size_t) rel_hdr
->sh_size
);
1228 if (allocated
== NULL
)
1231 if (bfd_seek (abfd
, rel_hdr
->sh_offset
, SEEK_SET
) != 0
1232 || (bfd_read (allocated
, 1, rel_hdr
->sh_size
, abfd
)
1233 != rel_hdr
->sh_size
))
1236 native_relocs
= (bfd_byte
*) allocated
;
1238 entsize
= rel_hdr
->sh_entsize
;
1239 BFD_ASSERT (entsize
== sizeof (Elf_External_Rel
)
1240 || entsize
== sizeof (Elf_External_Rela
));
1242 for (i
= 0, relent
= relents
;
1244 i
++, relent
++, native_relocs
+= entsize
)
1246 Elf_Internal_Rela rela
;
1247 Elf_Internal_Rel rel
;
1249 if (entsize
== sizeof (Elf_External_Rela
))
1250 elf_swap_reloca_in (abfd
, (Elf_External_Rela
*) native_relocs
, &rela
);
1253 elf_swap_reloc_in (abfd
, (Elf_External_Rel
*) native_relocs
, &rel
);
1254 rela
.r_offset
= rel
.r_offset
;
1255 rela
.r_info
= rel
.r_info
;
1259 /* The address of an ELF reloc is section relative for an object
1260 file, and absolute for an executable file or shared library.
1261 The address of a normal BFD reloc is always section relative,
1262 and the address of a dynamic reloc is absolute.. */
1263 if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0 || dynamic
)
1264 relent
->address
= rela
.r_offset
;
1266 relent
->address
= rela
.r_offset
- asect
->vma
;
1268 if (ELF_R_SYM (rela
.r_info
) == 0)
1269 relent
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
1274 ps
= symbols
+ ELF_R_SYM (rela
.r_info
) - 1;
1277 /* Canonicalize ELF section symbols. FIXME: Why? */
1278 if ((s
->flags
& BSF_SECTION_SYM
) == 0)
1279 relent
->sym_ptr_ptr
= ps
;
1281 relent
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
1284 relent
->addend
= rela
.r_addend
;
1286 if (entsize
== sizeof (Elf_External_Rela
))
1287 (*ebd
->elf_info_to_howto
) (abfd
, relent
, &rela
);
1289 (*ebd
->elf_info_to_howto_rel
) (abfd
, relent
, &rel
);
1292 if (allocated
!= NULL
)
1298 if (allocated
!= NULL
)
1303 /* Read in and swap the external relocs. */
1306 elf_slurp_reloc_table (abfd
, asect
, symbols
, dynamic
)
1312 struct bfd_elf_section_data
* const d
= elf_section_data (asect
);
1313 Elf_Internal_Shdr
*rel_hdr
;
1314 Elf_Internal_Shdr
*rel_hdr2
;
1315 bfd_size_type reloc_count
;
1316 bfd_size_type reloc_count2
;
1319 if (asect
->relocation
!= NULL
)
1324 if ((asect
->flags
& SEC_RELOC
) == 0
1325 || asect
->reloc_count
== 0)
1328 rel_hdr
= &d
->rel_hdr
;
1329 reloc_count
= rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
;
1330 rel_hdr2
= d
->rel_hdr2
;
1331 reloc_count2
= (rel_hdr2
1332 ? (rel_hdr2
->sh_size
/ rel_hdr2
->sh_entsize
)
1335 BFD_ASSERT (asect
->reloc_count
== reloc_count
+ reloc_count2
);
1336 BFD_ASSERT (asect
->rel_filepos
== rel_hdr
->sh_offset
1337 || (rel_hdr2
&& asect
->rel_filepos
== rel_hdr2
->sh_offset
));
1342 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1343 case because relocations against this section may use the
1344 dynamic symbol table, and in that case bfd_section_from_shdr
1345 in elf.c does not update the RELOC_COUNT. */
1346 if (asect
->_raw_size
== 0)
1349 rel_hdr
= &d
->this_hdr
;
1350 reloc_count
= rel_hdr
->sh_size
/ rel_hdr
->sh_entsize
;
1355 relents
= ((arelent
*)
1357 (reloc_count
+ reloc_count2
) * sizeof (arelent
)));
1358 if (relents
== NULL
)
1361 if (!elf_slurp_reloc_table_from_section (abfd
, asect
,
1362 rel_hdr
, reloc_count
,
1368 && !elf_slurp_reloc_table_from_section (abfd
, asect
,
1369 rel_hdr2
, reloc_count2
,
1370 relents
+ reloc_count
,
1375 asect
->relocation
= relents
;
1381 elf_debug_section (num
, hdr
)
1383 Elf_Internal_Shdr
*hdr
;
1385 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
,
1386 hdr
->bfd_section
!= NULL
? hdr
->bfd_section
->name
: "",
1389 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1390 (long) hdr
->sh_name
,
1391 (long) hdr
->sh_type
,
1392 (long) hdr
->sh_flags
);
1394 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1395 (long) hdr
->sh_addr
,
1396 (long) hdr
->sh_offset
,
1397 (long) hdr
->sh_size
);
1399 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1400 (long) hdr
->sh_link
,
1401 (long) hdr
->sh_info
,
1402 (long) hdr
->sh_addralign
);
1403 fprintf (stderr
, "sh_entsize = %ld\n",
1404 (long) hdr
->sh_entsize
);
1409 elf_debug_file (ehdrp
)
1410 Elf_Internal_Ehdr
*ehdrp
;
1412 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
1413 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
1414 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
1415 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
1416 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
1417 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
1418 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
1422 elf_symbol_flags (flags
)
1425 static char buffer
[1024];
1428 if (flags
& BSF_LOCAL
)
1429 strcat (buffer
, " local");
1431 if (flags
& BSF_GLOBAL
)
1432 strcat (buffer
, " global");
1434 if (flags
& BSF_DEBUGGING
)
1435 strcat (buffer
, " debug");
1437 if (flags
& BSF_FUNCTION
)
1438 strcat (buffer
, " function");
1440 if (flags
& BSF_KEEP
)
1441 strcat (buffer
, " keep");
1443 if (flags
& BSF_KEEP_G
)
1444 strcat (buffer
, " keep_g");
1446 if (flags
& BSF_WEAK
)
1447 strcat (buffer
, " weak");
1449 if (flags
& BSF_SECTION_SYM
)
1450 strcat (buffer
, " section-sym");
1452 if (flags
& BSF_OLD_COMMON
)
1453 strcat (buffer
, " old-common");
1455 if (flags
& BSF_NOT_AT_END
)
1456 strcat (buffer
, " not-at-end");
1458 if (flags
& BSF_CONSTRUCTOR
)
1459 strcat (buffer
, " constructor");
1461 if (flags
& BSF_WARNING
)
1462 strcat (buffer
, " warning");
1464 if (flags
& BSF_INDIRECT
)
1465 strcat (buffer
, " indirect");
1467 if (flags
& BSF_FILE
)
1468 strcat (buffer
, " file");
1470 if (flags
& DYNAMIC
)
1471 strcat (buffer
, " dynamic");
1473 if (flags
& ~(BSF_LOCAL
1488 strcat (buffer
, " unknown-bits");
1494 #include "elfcore.h"
1495 #include "elflink.h"
1497 /* Size-dependent data and functions. */
1498 const struct elf_size_info
NAME(_bfd_elf
,size_info
) = {
1499 sizeof (Elf_External_Ehdr
),
1500 sizeof (Elf_External_Phdr
),
1501 sizeof (Elf_External_Shdr
),
1502 sizeof (Elf_External_Rel
),
1503 sizeof (Elf_External_Rela
),
1504 sizeof (Elf_External_Sym
),
1505 sizeof (Elf_External_Dyn
),
1506 sizeof (Elf_External_Note
),
1509 ARCH_SIZE
, FILE_ALIGN
,
1510 ELFCLASS
, EV_CURRENT
,
1511 elf_write_out_phdrs
,
1512 elf_write_shdrs_and_ehdr
,
1514 elf_swap_symbol_out
,
1515 elf_slurp_reloc_table
,
1516 elf_slurp_symbol_table
,