source: trunk/src/binutils/bfd/elfcode.h@ 73

Last change on this file since 73 was 10, checked in by bird, 23 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 48.4 KB
Line 
1/* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001 Free Software Foundation, Inc.
4
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.
8
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.
16
17This file is part of BFD, the Binary File Descriptor library.
18
19This program is free software; you can redistribute it and/or modify
20it under the terms of the GNU General Public License as published by
21the Free Software Foundation; either version 2 of the License, or
22(at your option) any later version.
23
24This program is distributed in the hope that it will be useful,
25but WITHOUT ANY WARRANTY; without even the implied warranty of
26MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27GNU General Public License for more details.
28
29You should have received a copy of the GNU General Public License
30along with this program; if not, write to the Free Software
31Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
32
33/* Problems and other issues to resolve.
34
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.
42
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
47 "sections".
48
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)
53
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
56 and moved into elf.c.
57
58 (3) ELF section symbols are handled rather sloppily now. This should
59 be cleaned up, and ELF section symbols reconciled with BFD section
60 symbols.
61
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
64 it's cast in stone.
65 */
66
67#include "bfd.h"
68#include "sysdep.h"
69#include "bfdlink.h"
70#include "libbfd.h"
71#include "elf-bfd.h"
72
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)
81
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_write_relocs NAME(bfd_elf,write_relocs)
122#define elf_slurp_reloc_table NAME(bfd_elf,slurp_reloc_table)
123#define elf_link_create_dynamic_sections \
124 NAME(bfd_elf,link_create_dynamic_sections)
125#define elf_link_record_dynamic_symbol _bfd_elf_link_record_dynamic_symbol
126#define elf_bfd_final_link NAME(bfd_elf,bfd_final_link)
127#define elf_create_pointer_linker_section NAME(bfd_elf,create_pointer_linker_section)
128#define elf_finish_pointer_linker_section NAME(bfd_elf,finish_pointer_linker_section)
129#define elf_gc_sections NAME(_bfd_elf,gc_sections)
130#define elf_gc_common_finalize_got_offsets \
131 NAME(_bfd_elf,gc_common_finalize_got_offsets)
132#define elf_gc_common_final_link NAME(_bfd_elf,gc_common_final_link)
133#define elf_gc_record_vtinherit NAME(_bfd_elf,gc_record_vtinherit)
134#define elf_gc_record_vtentry NAME(_bfd_elf,gc_record_vtentry)
135#define elf_link_record_local_dynamic_symbol \
136 NAME(_bfd_elf,link_record_local_dynamic_symbol)
137
138#if ARCH_SIZE == 64
139#define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
140#define ELF_R_SYM(X) ELF64_R_SYM(X)
141#define ELF_R_TYPE(X) ELF64_R_TYPE(X)
142#define ELFCLASS ELFCLASS64
143#define FILE_ALIGN 8
144#define LOG_FILE_ALIGN 3
145#endif
146#if ARCH_SIZE == 32
147#define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
148#define ELF_R_SYM(X) ELF32_R_SYM(X)
149#define ELF_R_TYPE(X) ELF32_R_TYPE(X)
150#define ELFCLASS ELFCLASS32
151#define FILE_ALIGN 4
152#define LOG_FILE_ALIGN 2
153#endif
154
155/* Static functions */
156
157static void elf_swap_ehdr_in
158 PARAMS ((bfd *, const Elf_External_Ehdr *, Elf_Internal_Ehdr *));
159static void elf_swap_ehdr_out
160 PARAMS ((bfd *, const Elf_Internal_Ehdr *, Elf_External_Ehdr *));
161static void elf_swap_shdr_in
162 PARAMS ((bfd *, const Elf_External_Shdr *, Elf_Internal_Shdr *));
163static void elf_swap_shdr_out
164 PARAMS ((bfd *, const Elf_Internal_Shdr *, Elf_External_Shdr *));
165
166#define elf_stringtab_init _bfd_elf_stringtab_init
167
168#define section_from_elf_index bfd_section_from_elf_index
169
170static boolean elf_slurp_reloc_table_from_section
171 PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, bfd_size_type,
172 arelent *, asymbol **, boolean));
173
174static boolean elf_file_p PARAMS ((Elf_External_Ehdr *));
175
176#ifdef DEBUG
177static void elf_debug_section PARAMS ((int, Elf_Internal_Shdr *));
178static void elf_debug_file PARAMS ((Elf_Internal_Ehdr *));
179static char *elf_symbol_flags PARAMS ((flagword));
180#endif
181
182
183/* Structure swapping routines */
184
185/* Should perhaps use put_offset, put_word, etc. For now, the two versions
186 can be handled by explicitly specifying 32 bits or "the long type". */
187#if ARCH_SIZE == 64
188#define put_word bfd_h_put_64
189#define put_signed_word bfd_h_put_signed_64
190#define get_word bfd_h_get_64
191#define get_signed_word bfd_h_get_signed_64
192#endif
193#if ARCH_SIZE == 32
194#define put_word bfd_h_put_32
195#define put_signed_word bfd_h_put_signed_32
196#define get_word bfd_h_get_32
197#define get_signed_word bfd_h_get_signed_32
198#endif
199
200/* Translate an ELF symbol in external format into an ELF symbol in internal
201 format. */
202
203void
204elf_swap_symbol_in (abfd, src, dst)
205 bfd *abfd;
206 const Elf_External_Sym *src;
207 Elf_Internal_Sym *dst;
208{
209 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
210
211 dst->st_name = bfd_h_get_32 (abfd, (bfd_byte *) src->st_name);
212 if (signed_vma)
213 dst->st_value = get_signed_word (abfd, (bfd_byte *) src->st_value);
214 else
215 dst->st_value = get_word (abfd, (bfd_byte *) src->st_value);
216 dst->st_size = get_word (abfd, (bfd_byte *) src->st_size);
217 dst->st_info = bfd_h_get_8 (abfd, (bfd_byte *) src->st_info);
218 dst->st_other = bfd_h_get_8 (abfd, (bfd_byte *) src->st_other);
219 dst->st_shndx = bfd_h_get_16 (abfd, (bfd_byte *) src->st_shndx);
220}
221
222/* Translate an ELF symbol in internal format into an ELF symbol in external
223 format. */
224
225void
226elf_swap_symbol_out (abfd, src, cdst)
227 bfd *abfd;
228 const Elf_Internal_Sym *src;
229 PTR cdst;
230{
231 Elf_External_Sym *dst = (Elf_External_Sym *) cdst;
232 bfd_h_put_32 (abfd, src->st_name, dst->st_name);
233 put_word (abfd, src->st_value, dst->st_value);
234 put_word (abfd, src->st_size, dst->st_size);
235 bfd_h_put_8 (abfd, src->st_info, dst->st_info);
236 bfd_h_put_8 (abfd, src->st_other, dst->st_other);
237 bfd_h_put_16 (abfd, src->st_shndx, dst->st_shndx);
238}
239
240/* Translate an ELF file header in external format into an ELF file header in
241 internal format. */
242
243static void
244elf_swap_ehdr_in (abfd, src, dst)
245 bfd *abfd;
246 const Elf_External_Ehdr *src;
247 Elf_Internal_Ehdr *dst;
248{
249 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
250 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
251 dst->e_type = bfd_h_get_16 (abfd, (bfd_byte *) src->e_type);
252 dst->e_machine = bfd_h_get_16 (abfd, (bfd_byte *) src->e_machine);
253 dst->e_version = bfd_h_get_32 (abfd, (bfd_byte *) src->e_version);
254 if (signed_vma)
255 dst->e_entry = get_signed_word (abfd, (bfd_byte *) src->e_entry);
256 else
257 dst->e_entry = get_word (abfd, (bfd_byte *) src->e_entry);
258 dst->e_phoff = get_word (abfd, (bfd_byte *) src->e_phoff);
259 dst->e_shoff = get_word (abfd, (bfd_byte *) src->e_shoff);
260 dst->e_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->e_flags);
261 dst->e_ehsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_ehsize);
262 dst->e_phentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phentsize);
263 dst->e_phnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_phnum);
264 dst->e_shentsize = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shentsize);
265 dst->e_shnum = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shnum);
266 dst->e_shstrndx = bfd_h_get_16 (abfd, (bfd_byte *) src->e_shstrndx);
267}
268
269/* Translate an ELF file header in internal format into an ELF file header in
270 external format. */
271
272static void
273elf_swap_ehdr_out (abfd, src, dst)
274 bfd *abfd;
275 const Elf_Internal_Ehdr *src;
276 Elf_External_Ehdr *dst;
277{
278 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
279 memcpy (dst->e_ident, src->e_ident, EI_NIDENT);
280 /* note that all elements of dst are *arrays of unsigned char* already... */
281 bfd_h_put_16 (abfd, src->e_type, dst->e_type);
282 bfd_h_put_16 (abfd, src->e_machine, dst->e_machine);
283 bfd_h_put_32 (abfd, src->e_version, dst->e_version);
284 if (signed_vma)
285 put_signed_word (abfd, src->e_entry, dst->e_entry);
286 else
287 put_word (abfd, src->e_entry, dst->e_entry);
288 put_word (abfd, src->e_phoff, dst->e_phoff);
289 put_word (abfd, src->e_shoff, dst->e_shoff);
290 bfd_h_put_32 (abfd, src->e_flags, dst->e_flags);
291 bfd_h_put_16 (abfd, src->e_ehsize, dst->e_ehsize);
292 bfd_h_put_16 (abfd, src->e_phentsize, dst->e_phentsize);
293 bfd_h_put_16 (abfd, src->e_phnum, dst->e_phnum);
294 bfd_h_put_16 (abfd, src->e_shentsize, dst->e_shentsize);
295 bfd_h_put_16 (abfd, src->e_shnum, dst->e_shnum);
296 bfd_h_put_16 (abfd, src->e_shstrndx, dst->e_shstrndx);
297}
298
299/* Translate an ELF section header table entry in external format into an
300 ELF section header table entry in internal format. */
301
302static void
303elf_swap_shdr_in (abfd, src, dst)
304 bfd *abfd;
305 const Elf_External_Shdr *src;
306 Elf_Internal_Shdr *dst;
307{
308 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
309
310 dst->sh_name = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_name);
311 dst->sh_type = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_type);
312 dst->sh_flags = get_word (abfd, (bfd_byte *) src->sh_flags);
313 if (signed_vma)
314 dst->sh_addr = get_signed_word (abfd, (bfd_byte *) src->sh_addr);
315 else
316 dst->sh_addr = get_word (abfd, (bfd_byte *) src->sh_addr);
317 dst->sh_offset = get_word (abfd, (bfd_byte *) src->sh_offset);
318 dst->sh_size = get_word (abfd, (bfd_byte *) src->sh_size);
319 dst->sh_link = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_link);
320 dst->sh_info = bfd_h_get_32 (abfd, (bfd_byte *) src->sh_info);
321 dst->sh_addralign = get_word (abfd, (bfd_byte *) src->sh_addralign);
322 dst->sh_entsize = get_word (abfd, (bfd_byte *) src->sh_entsize);
323 dst->bfd_section = NULL;
324 dst->contents = NULL;
325}
326
327/* Translate an ELF section header table entry in internal format into an
328 ELF section header table entry in external format. */
329
330static void
331elf_swap_shdr_out (abfd, src, dst)
332 bfd *abfd;
333 const Elf_Internal_Shdr *src;
334 Elf_External_Shdr *dst;
335{
336 /* note that all elements of dst are *arrays of unsigned char* already... */
337 bfd_h_put_32 (abfd, src->sh_name, dst->sh_name);
338 bfd_h_put_32 (abfd, src->sh_type, dst->sh_type);
339 put_word (abfd, src->sh_flags, dst->sh_flags);
340 put_word (abfd, src->sh_addr, dst->sh_addr);
341 put_word (abfd, src->sh_offset, dst->sh_offset);
342 put_word (abfd, src->sh_size, dst->sh_size);
343 bfd_h_put_32 (abfd, src->sh_link, dst->sh_link);
344 bfd_h_put_32 (abfd, src->sh_info, dst->sh_info);
345 put_word (abfd, src->sh_addralign, dst->sh_addralign);
346 put_word (abfd, src->sh_entsize, dst->sh_entsize);
347}
348
349/* Translate an ELF program header table entry in external format into an
350 ELF program header table entry in internal format. */
351
352void
353elf_swap_phdr_in (abfd, src, dst)
354 bfd *abfd;
355 const Elf_External_Phdr *src;
356 Elf_Internal_Phdr *dst;
357{
358 int signed_vma = get_elf_backend_data (abfd)->sign_extend_vma;
359
360 dst->p_type = bfd_h_get_32 (abfd, (bfd_byte *) src->p_type);
361 dst->p_flags = bfd_h_get_32 (abfd, (bfd_byte *) src->p_flags);
362 dst->p_offset = get_word (abfd, (bfd_byte *) src->p_offset);
363 if (signed_vma)
364 {
365 dst->p_vaddr = get_signed_word (abfd, (bfd_byte *) src->p_vaddr);
366 dst->p_paddr = get_signed_word (abfd, (bfd_byte *) src->p_paddr);
367 }
368 else
369 {
370 dst->p_vaddr = get_word (abfd, (bfd_byte *) src->p_vaddr);
371 dst->p_paddr = get_word (abfd, (bfd_byte *) src->p_paddr);
372 }
373 dst->p_filesz = get_word (abfd, (bfd_byte *) src->p_filesz);
374 dst->p_memsz = get_word (abfd, (bfd_byte *) src->p_memsz);
375 dst->p_align = get_word (abfd, (bfd_byte *) src->p_align);
376}
377
378void
379elf_swap_phdr_out (abfd, src, dst)
380 bfd *abfd;
381 const Elf_Internal_Phdr *src;
382 Elf_External_Phdr *dst;
383{
384 /* note that all elements of dst are *arrays of unsigned char* already... */
385 bfd_h_put_32 (abfd, src->p_type, dst->p_type);
386 put_word (abfd, src->p_offset, dst->p_offset);
387 put_word (abfd, src->p_vaddr, dst->p_vaddr);
388 put_word (abfd, src->p_paddr, dst->p_paddr);
389 put_word (abfd, src->p_filesz, dst->p_filesz);
390 put_word (abfd, src->p_memsz, dst->p_memsz);
391 bfd_h_put_32 (abfd, src->p_flags, dst->p_flags);
392 put_word (abfd, src->p_align, dst->p_align);
393}
394
395/* Translate an ELF reloc from external format to internal format. */
396INLINE void
397elf_swap_reloc_in (abfd, src, dst)
398 bfd *abfd;
399 const Elf_External_Rel *src;
400 Elf_Internal_Rel *dst;
401{
402 dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
403 dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
404}
405
406INLINE void
407elf_swap_reloca_in (abfd, src, dst)
408 bfd *abfd;
409 const Elf_External_Rela *src;
410 Elf_Internal_Rela *dst;
411{
412 dst->r_offset = get_word (abfd, (bfd_byte *) src->r_offset);
413 dst->r_info = get_word (abfd, (bfd_byte *) src->r_info);
414 dst->r_addend = get_signed_word (abfd, (bfd_byte *) src->r_addend);
415}
416
417/* Translate an ELF reloc from internal format to external format. */
418INLINE void
419elf_swap_reloc_out (abfd, src, dst)
420 bfd *abfd;
421 const Elf_Internal_Rel *src;
422 Elf_External_Rel *dst;
423{
424 put_word (abfd, src->r_offset, dst->r_offset);
425 put_word (abfd, src->r_info, dst->r_info);
426}
427
428INLINE void
429elf_swap_reloca_out (abfd, src, dst)
430 bfd *abfd;
431 const Elf_Internal_Rela *src;
432 Elf_External_Rela *dst;
433{
434 put_word (abfd, src->r_offset, dst->r_offset);
435 put_word (abfd, src->r_info, dst->r_info);
436 put_signed_word (abfd, src->r_addend, dst->r_addend);
437}
438
439INLINE void
440elf_swap_dyn_in (abfd, p, dst)
441 bfd *abfd;
442 const PTR p;
443 Elf_Internal_Dyn *dst;
444{
445 const Elf_External_Dyn *src = (const Elf_External_Dyn *) p;
446
447 dst->d_tag = get_word (abfd, src->d_tag);
448 dst->d_un.d_val = get_word (abfd, src->d_un.d_val);
449}
450
451INLINE void
452elf_swap_dyn_out (abfd, src, p)
453 bfd *abfd;
454 const Elf_Internal_Dyn *src;
455 PTR p;
456{
457 Elf_External_Dyn *dst = (Elf_External_Dyn *) p;
458
459 put_word (abfd, src->d_tag, dst->d_tag);
460 put_word (abfd, src->d_un.d_val, dst->d_un.d_val);
461}
462
463
464/* ELF .o/exec file reading */
465
466/* Begin processing a given object.
467
468 First we validate the file by reading in the ELF header and checking
469 the magic number. */
470
471static INLINE boolean
472elf_file_p (x_ehdrp)
473 Elf_External_Ehdr *x_ehdrp;
474{
475 return ((x_ehdrp->e_ident[EI_MAG0] == ELFMAG0)
476 && (x_ehdrp->e_ident[EI_MAG1] == ELFMAG1)
477 && (x_ehdrp->e_ident[EI_MAG2] == ELFMAG2)
478 && (x_ehdrp->e_ident[EI_MAG3] == ELFMAG3));
479}
480
481/* Check to see if the file associated with ABFD matches the target vector
482 that ABFD points to.
483
484 Note that we may be called several times with the same ABFD, but different
485 target vectors, most of which will not match. We have to avoid leaving
486 any side effects in ABFD, or any data it points to (like tdata), if the
487 file does not match the target vector. */
488
489const bfd_target *
490elf_object_p (abfd)
491 bfd *abfd;
492{
493 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
494 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
495 Elf_External_Shdr x_shdr; /* Section header table entry, external form */
496 Elf_Internal_Shdr *i_shdrp = NULL; /* Section header table, internal form */
497 unsigned int shindex;
498 char *shstrtab; /* Internal copy of section header stringtab */
499 struct elf_backend_data *ebd;
500 struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
501 struct sec *preserved_sections = abfd->sections;
502 unsigned int preserved_section_count = abfd->section_count;
503 enum bfd_architecture previous_arch = bfd_get_arch (abfd);
504 unsigned long previous_mach = bfd_get_mach (abfd);
505 struct elf_obj_tdata *new_tdata = NULL;
506 asection *s;
507
508 /* Clear section information, since there might be a recognized bfd that
509 we now check if we can replace, and we don't want to append to it. */
510 abfd->sections = NULL;
511 abfd->section_count = 0;
512
513 /* Read in the ELF header in external format. */
514
515 if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
516 {
517 if (bfd_get_error () != bfd_error_system_call)
518 goto got_wrong_format_error;
519 else
520 goto got_no_match;
521 }
522
523 /* Now check to see if we have a valid ELF file, and one that BFD can
524 make use of. The magic number must match, the address size ('class')
525 and byte-swapping must match our XVEC entry, and it must have a
526 section header table (FIXME: See comments re sections at top of this
527 file). */
528
529 if ((elf_file_p (&x_ehdr) == false) ||
530 (x_ehdr.e_ident[EI_VERSION] != EV_CURRENT) ||
531 (x_ehdr.e_ident[EI_CLASS] != ELFCLASS))
532 goto got_wrong_format_error;
533
534 /* Check that file's byte order matches xvec's */
535 switch (x_ehdr.e_ident[EI_DATA])
536 {
537 case ELFDATA2MSB: /* Big-endian */
538 if (! bfd_header_big_endian (abfd))
539 goto got_wrong_format_error;
540 break;
541 case ELFDATA2LSB: /* Little-endian */
542 if (! bfd_header_little_endian (abfd))
543 goto got_wrong_format_error;
544 break;
545 case ELFDATANONE: /* No data encoding specified */
546 default: /* Unknown data encoding specified */
547 goto got_wrong_format_error;
548 }
549
550 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
551 the tdata pointer in the bfd. */
552
553 new_tdata = ((struct elf_obj_tdata *)
554 bfd_zalloc (abfd, sizeof (struct elf_obj_tdata)));
555 if (new_tdata == NULL)
556 goto got_no_match;
557 elf_tdata (abfd) = new_tdata;
558
559 /* Now that we know the byte order, swap in the rest of the header */
560 i_ehdrp = elf_elfheader (abfd);
561 elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
562#if DEBUG & 1
563 elf_debug_file (i_ehdrp);
564#endif
565
566 /* Reject ET_CORE (header indicates core file, not object file) */
567 if (i_ehdrp->e_type == ET_CORE)
568 goto got_wrong_format_error;
569
570 /* If there is no section header table, we're hosed. */
571 if (i_ehdrp->e_shoff == 0)
572 goto got_wrong_format_error;
573
574 /* As a simple sanity check, verify that the what BFD thinks is the
575 size of each section header table entry actually matches the size
576 recorded in the file. */
577 if (i_ehdrp->e_shentsize != sizeof (x_shdr))
578 goto got_wrong_format_error;
579
580 ebd = get_elf_backend_data (abfd);
581
582 /* Check that the ELF e_machine field matches what this particular
583 BFD format expects. */
584 if (ebd->elf_machine_code != i_ehdrp->e_machine
585 && (ebd->elf_machine_alt1 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
586 && (ebd->elf_machine_alt2 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
587 {
588 const bfd_target * const *target_ptr;
589
590 if (ebd->elf_machine_code != EM_NONE)
591 goto got_wrong_format_error;
592
593 /* This is the generic ELF target. Let it match any ELF target
594 for which we do not have a specific backend. */
595 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
596 {
597 struct elf_backend_data *back;
598
599 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
600 continue;
601 back = (struct elf_backend_data *) (*target_ptr)->backend_data;
602 if (back->elf_machine_code == i_ehdrp->e_machine
603 || (back->elf_machine_alt1 != 0
604 && back->elf_machine_alt1 == i_ehdrp->e_machine)
605 || (back->elf_machine_alt2 != 0
606 && back->elf_machine_alt2 == i_ehdrp->e_machine))
607 {
608 /* target_ptr is an ELF backend which matches this
609 object file, so reject the generic ELF target. */
610 goto got_wrong_format_error;
611 }
612 }
613 }
614
615 if (i_ehdrp->e_type == ET_EXEC)
616 abfd->flags |= EXEC_P;
617 else if (i_ehdrp->e_type == ET_DYN)
618 abfd->flags |= DYNAMIC;
619
620 if (i_ehdrp->e_phnum > 0)
621 abfd->flags |= D_PAGED;
622
623 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
624 {
625 /* It's OK if this fails for the generic target. */
626 if (ebd->elf_machine_code != EM_NONE)
627 goto got_no_match;
628 }
629
630 /* Remember the entry point specified in the ELF file header. */
631 bfd_set_start_address (abfd, i_ehdrp->e_entry);
632
633 /* Allocate space for a copy of the section header table in
634 internal form, seek to the section header table in the file,
635 read it in, and convert it to internal form. */
636 i_shdrp = ((Elf_Internal_Shdr *)
637 bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum));
638 elf_elfsections (abfd) = ((Elf_Internal_Shdr **)
639 bfd_alloc (abfd,
640 sizeof (i_shdrp) * i_ehdrp->e_shnum));
641 if (!i_shdrp || !elf_elfsections (abfd))
642 goto got_no_match;
643 if (bfd_seek (abfd, i_ehdrp->e_shoff, SEEK_SET) != 0)
644 goto got_no_match;
645 for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
646 {
647 if (bfd_read ((PTR) & x_shdr, sizeof x_shdr, 1, abfd) != sizeof (x_shdr))
648 goto got_no_match;
649 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
650 elf_elfsections (abfd)[shindex] = i_shdrp + shindex;
651
652 /* If the section is loaded, but not page aligned, clear
653 D_PAGED. */
654 if ((i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
655 && i_shdrp[shindex].sh_type != SHT_NOBITS
656 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
657 % ebd->maxpagesize)
658 != 0))
659 abfd->flags &= ~D_PAGED;
660 }
661 if (i_ehdrp->e_shstrndx)
662 {
663 if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
664 goto got_no_match;
665 }
666
667 /* Read in the program headers. */
668 if (i_ehdrp->e_phnum == 0)
669 elf_tdata (abfd)->phdr = NULL;
670 else
671 {
672 Elf_Internal_Phdr *i_phdr;
673 unsigned int i;
674
675 elf_tdata (abfd)->phdr = ((Elf_Internal_Phdr *)
676 bfd_alloc (abfd,
677 (i_ehdrp->e_phnum
678 * sizeof (Elf_Internal_Phdr))));
679 if (elf_tdata (abfd)->phdr == NULL)
680 goto got_no_match;
681 if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0)
682 goto got_no_match;
683 i_phdr = elf_tdata (abfd)->phdr;
684 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
685 {
686 Elf_External_Phdr x_phdr;
687
688 if (bfd_read ((PTR) &x_phdr, sizeof x_phdr, 1, abfd)
689 != sizeof x_phdr)
690 goto got_no_match;
691 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
692 }
693 }
694
695 /* Read in the string table containing the names of the sections. We
696 will need the base pointer to this table later. */
697 /* We read this inline now, so that we don't have to go through
698 bfd_section_from_shdr with it (since this particular strtab is
699 used to find all of the ELF section names.) */
700
701 shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
702 if (!shstrtab)
703 goto got_no_match;
704
705 /* Once all of the section headers have been read and converted, we
706 can start processing them. Note that the first section header is
707 a dummy placeholder entry, so we ignore it. */
708
709 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
710 {
711 if (! bfd_section_from_shdr (abfd, shindex))
712 goto got_no_match;
713 }
714
715 /* Let the backend double check the format and override global
716 information. */
717 if (ebd->elf_backend_object_p)
718 {
719 if ((*ebd->elf_backend_object_p) (abfd) == false)
720 goto got_wrong_format_error;
721 }
722
723 /* If we have created any reloc sections that are associated with
724 debugging sections, mark the reloc sections as debugging as well. */
725 for (s = abfd->sections; s != NULL; s = s->next)
726 {
727 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
728 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
729 && elf_section_data (s)->this_hdr.sh_info > 0)
730 {
731 unsigned long targ_index;
732 asection *targ_sec;
733
734 targ_index = elf_section_data (s)->this_hdr.sh_info;
735 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
736 if (targ_sec != NULL
737 && (targ_sec->flags & SEC_DEBUGGING) != 0)
738 s->flags |= SEC_DEBUGGING;
739 }
740 }
741
742 return (abfd->xvec);
743
744 got_wrong_format_error:
745 /* There is way too much undoing of half-known state here. The caller,
746 bfd_check_format_matches, really shouldn't iterate on live bfd's to
747 check match/no-match like it does. We have to rely on that a call to
748 bfd_default_set_arch_mach with the previously known mach, undoes what
749 was done by the first bfd_default_set_arch_mach (with mach 0) here.
750 For this to work, only elf-data and the mach may be changed by the
751 target-specific elf_backend_object_p function. Note that saving the
752 whole bfd here and restoring it would be even worse; the first thing
753 you notice is that the cached bfd file position gets out of sync. */
754 bfd_default_set_arch_mach (abfd, previous_arch, previous_mach);
755 bfd_set_error (bfd_error_wrong_format);
756 got_no_match:
757 if (new_tdata != NULL
758 && new_tdata->elf_sect_ptr != NULL)
759 bfd_release (abfd, new_tdata->elf_sect_ptr);
760 if (i_shdrp != NULL)
761 bfd_release (abfd, i_shdrp);
762 if (new_tdata != NULL)
763 bfd_release (abfd, new_tdata);
764 elf_tdata (abfd) = preserved_tdata;
765 abfd->sections = preserved_sections;
766 abfd->section_count = preserved_section_count;
767 return (NULL);
768}
769
770
771/* ELF .o/exec file writing */
772
773/* Write out the relocs. */
774
775void
776elf_write_relocs (abfd, sec, data)
777 bfd *abfd;
778 asection *sec;
779 PTR data;
780{
781 boolean *failedp = (boolean *) data;
782 Elf_Internal_Shdr *rela_hdr;
783 Elf_External_Rela *outbound_relocas;
784 Elf_External_Rel *outbound_relocs;
785 unsigned int idx;
786 int use_rela_p;
787 asymbol *last_sym = 0;
788 int last_sym_idx = 0;
789
790 /* If we have already failed, don't do anything. */
791 if (*failedp)
792 return;
793
794 if ((sec->flags & SEC_RELOC) == 0)
795 return;
796
797 /* The linker backend writes the relocs out itself, and sets the
798 reloc_count field to zero to inhibit writing them here. Also,
799 sometimes the SEC_RELOC flag gets set even when there aren't any
800 relocs. */
801 if (sec->reloc_count == 0)
802 return;
803
804 rela_hdr = &elf_section_data (sec)->rel_hdr;
805
806 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
807 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
808 if (rela_hdr->contents == NULL)
809 {
810 *failedp = true;
811 return;
812 }
813
814 /* Figure out whether the relocations are RELA or REL relocations. */
815 if (rela_hdr->sh_type == SHT_RELA)
816 use_rela_p = true;
817 else if (rela_hdr->sh_type == SHT_REL)
818 use_rela_p = false;
819 else
820 /* Every relocation section should be either an SHT_RELA or an
821 SHT_REL section. */
822 abort ();
823
824 /* orelocation has the data, reloc_count has the count... */
825 if (use_rela_p)
826 {
827 outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
828
829 for (idx = 0; idx < sec->reloc_count; idx++)
830 {
831 Elf_Internal_Rela dst_rela;
832 Elf_External_Rela *src_rela;
833 arelent *ptr;
834 asymbol *sym;
835 int n;
836
837 ptr = sec->orelocation[idx];
838 src_rela = outbound_relocas + idx;
839
840 /* The address of an ELF reloc is section relative for an object
841 file, and absolute for an executable file or shared library.
842 The address of a BFD reloc is always section relative. */
843 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
844 dst_rela.r_offset = ptr->address;
845 else
846 dst_rela.r_offset = ptr->address + sec->vma;
847
848 sym = *ptr->sym_ptr_ptr;
849 if (sym == last_sym)
850 n = last_sym_idx;
851 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
852 n = STN_UNDEF;
853 else
854 {
855 last_sym = sym;
856 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
857 if (n < 0)
858 {
859 *failedp = true;
860 return;
861 }
862 last_sym_idx = n;
863 }
864
865 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
866 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
867 && ! _bfd_elf_validate_reloc (abfd, ptr))
868 {
869 *failedp = true;
870 return;
871 }
872
873 dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
874
875 dst_rela.r_addend = ptr->addend;
876 elf_swap_reloca_out (abfd, &dst_rela, src_rela);
877 }
878 }
879 else
880 /* REL relocations */
881 {
882 outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
883
884 for (idx = 0; idx < sec->reloc_count; idx++)
885 {
886 Elf_Internal_Rel dst_rel;
887 Elf_External_Rel *src_rel;
888 arelent *ptr;
889 int n;
890 asymbol *sym;
891
892 ptr = sec->orelocation[idx];
893 sym = *ptr->sym_ptr_ptr;
894 src_rel = outbound_relocs + idx;
895
896 /* The address of an ELF reloc is section relative for an object
897 file, and absolute for an executable file or shared library.
898 The address of a BFD reloc is always section relative. */
899 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
900 dst_rel.r_offset = ptr->address;
901 else
902 dst_rel.r_offset = ptr->address + sec->vma;
903
904 if (sym == last_sym)
905 n = last_sym_idx;
906 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
907 n = STN_UNDEF;
908 else
909 {
910 last_sym = sym;
911 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
912 if (n < 0)
913 {
914 *failedp = true;
915 return;
916 }
917 last_sym_idx = n;
918 }
919
920 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
921 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
922 && ! _bfd_elf_validate_reloc (abfd, ptr))
923 {
924 *failedp = true;
925 return;
926 }
927
928 dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
929
930 elf_swap_reloc_out (abfd, &dst_rel, src_rel);
931 }
932 }
933}
934
935/* Write out the program headers. */
936
937int
938elf_write_out_phdrs (abfd, phdr, count)
939 bfd *abfd;
940 const Elf_Internal_Phdr *phdr;
941 int count;
942{
943 while (count--)
944 {
945 Elf_External_Phdr extphdr;
946 elf_swap_phdr_out (abfd, phdr, &extphdr);
947 if (bfd_write (&extphdr, sizeof (Elf_External_Phdr), 1, abfd)
948 != sizeof (Elf_External_Phdr))
949 return -1;
950 phdr++;
951 }
952 return 0;
953}
954
955/* Write out the section headers and the ELF file header. */
956
957boolean
958elf_write_shdrs_and_ehdr (abfd)
959 bfd *abfd;
960{
961 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
962 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
963 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
964 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
965 unsigned int count;
966
967 i_ehdrp = elf_elfheader (abfd);
968 i_shdrp = elf_elfsections (abfd);
969
970 /* swap the header before spitting it out... */
971
972#if DEBUG & 1
973 elf_debug_file (i_ehdrp);
974#endif
975 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
976 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
977 || (bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd)
978 != sizeof (x_ehdr)))
979 return false;
980
981 /* at this point we've concocted all the ELF sections... */
982 x_shdrp = (Elf_External_Shdr *)
983 bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
984 if (!x_shdrp)
985 return false;
986
987 for (count = 0; count < i_ehdrp->e_shnum; count++)
988 {
989#if DEBUG & 2
990 elf_debug_section (count, i_shdrp[count]);
991#endif
992 elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
993 }
994 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
995 || (bfd_write ((PTR) x_shdrp, sizeof (*x_shdrp), i_ehdrp->e_shnum, abfd)
996 != sizeof (*x_shdrp) * i_ehdrp->e_shnum))
997 return false;
998
999 /* need to dump the string table too... */
1000
1001 return true;
1002}
1003
1004long
1005elf_slurp_symbol_table (abfd, symptrs, dynamic)
1006 bfd *abfd;
1007 asymbol **symptrs; /* Buffer for generated bfd symbols */
1008 boolean dynamic;
1009{
1010 Elf_Internal_Shdr *hdr;
1011 Elf_Internal_Shdr *verhdr;
1012 unsigned long symcount; /* Number of external ELF symbols */
1013 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1014 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1015 Elf_Internal_Sym i_sym;
1016 Elf_External_Sym *x_symp = NULL;
1017 Elf_External_Versym *x_versymp = NULL;
1018
1019 /* Read each raw ELF symbol, converting from external ELF form to
1020 internal ELF form, and then using the information to create a
1021 canonical bfd symbol table entry.
1022
1023 Note that we allocate the initial bfd canonical symbol buffer
1024 based on a one-to-one mapping of the ELF symbols to canonical
1025 symbols. We actually use all the ELF symbols, so there will be no
1026 space left over at the end. When we have all the symbols, we
1027 build the caller's pointer vector. */
1028
1029 if (! dynamic)
1030 {
1031 hdr = &elf_tdata (abfd)->symtab_hdr;
1032 verhdr = NULL;
1033 }
1034 else
1035 {
1036 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1037 if (elf_dynversym (abfd) == 0)
1038 verhdr = NULL;
1039 else
1040 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1041 if ((elf_tdata (abfd)->dynverdef_section != 0
1042 && elf_tdata (abfd)->verdef == NULL)
1043 || (elf_tdata (abfd)->dynverref_section != 0
1044 && elf_tdata (abfd)->verref == NULL))
1045 {
1046 if (! _bfd_elf_slurp_version_tables (abfd))
1047 return -1;
1048 }
1049 }
1050
1051 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
1052 return -1;
1053
1054 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1055
1056 if (symcount == 0)
1057 sym = symbase = NULL;
1058 else
1059 {
1060 unsigned long i;
1061
1062 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
1063 return -1;
1064
1065 symbase = ((elf_symbol_type *)
1066 bfd_zalloc (abfd, symcount * sizeof (elf_symbol_type)));
1067 if (symbase == (elf_symbol_type *) NULL)
1068 return -1;
1069 sym = symbase;
1070
1071 /* Temporarily allocate room for the raw ELF symbols. */
1072 x_symp = ((Elf_External_Sym *)
1073 bfd_malloc (symcount * sizeof (Elf_External_Sym)));
1074 if (x_symp == NULL && symcount != 0)
1075 goto error_return;
1076
1077 if (bfd_read ((PTR) x_symp, sizeof (Elf_External_Sym), symcount, abfd)
1078 != symcount * sizeof (Elf_External_Sym))
1079 goto error_return;
1080
1081 /* Read the raw ELF version symbol information. */
1082
1083 if (verhdr != NULL
1084 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1085 {
1086 (*_bfd_error_handler)
1087 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1088 abfd->filename,
1089 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1090 symcount);
1091
1092 /* Slurp in the symbols without the version information,
1093 since that is more helpful than just quitting. */
1094 verhdr = NULL;
1095 }
1096
1097 if (verhdr != NULL)
1098 {
1099 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1100 goto error_return;
1101
1102 x_versymp = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1103 if (x_versymp == NULL && verhdr->sh_size != 0)
1104 goto error_return;
1105
1106 if (bfd_read ((PTR) x_versymp, 1, verhdr->sh_size, abfd)
1107 != verhdr->sh_size)
1108 goto error_return;
1109 }
1110
1111 /* Skip first symbol, which is a null dummy. */
1112 for (i = 1; i < symcount; i++)
1113 {
1114 elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
1115 memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
1116#ifdef ELF_KEEP_EXTSYM
1117 memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
1118#endif
1119 sym->symbol.the_bfd = abfd;
1120
1121 sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1122 hdr->sh_link,
1123 i_sym.st_name);
1124
1125 sym->symbol.value = i_sym.st_value;
1126
1127 if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
1128 {
1129 sym->symbol.section = section_from_elf_index (abfd,
1130 i_sym.st_shndx);
1131 if (sym->symbol.section == NULL)
1132 {
1133 /* This symbol is in a section for which we did not
1134 create a BFD section. Just use bfd_abs_section,
1135 although it is wrong. FIXME. */
1136 sym->symbol.section = bfd_abs_section_ptr;
1137 }
1138 }
1139 else if (i_sym.st_shndx == SHN_ABS)
1140 {
1141 sym->symbol.section = bfd_abs_section_ptr;
1142 }
1143 else if (i_sym.st_shndx == SHN_COMMON)
1144 {
1145 sym->symbol.section = bfd_com_section_ptr;
1146 /* Elf puts the alignment into the `value' field, and
1147 the size into the `size' field. BFD wants to see the
1148 size in the value field, and doesn't care (at the
1149 moment) about the alignment. */
1150 sym->symbol.value = i_sym.st_size;
1151 }
1152 else if (i_sym.st_shndx == SHN_UNDEF)
1153 {
1154 sym->symbol.section = bfd_und_section_ptr;
1155 }
1156 else
1157 sym->symbol.section = bfd_abs_section_ptr;
1158
1159 /* If this is a relocateable file, then the symbol value is
1160 already section relative. */
1161 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1162 sym->symbol.value -= sym->symbol.section->vma;
1163
1164 switch (ELF_ST_BIND (i_sym.st_info))
1165 {
1166 case STB_LOCAL:
1167 sym->symbol.flags |= BSF_LOCAL;
1168 break;
1169 case STB_GLOBAL:
1170 if (i_sym.st_shndx != SHN_UNDEF
1171 && i_sym.st_shndx != SHN_COMMON)
1172 sym->symbol.flags |= BSF_GLOBAL;
1173 break;
1174 case STB_WEAK:
1175 sym->symbol.flags |= BSF_WEAK;
1176 break;
1177 }
1178
1179 switch (ELF_ST_TYPE (i_sym.st_info))
1180 {
1181 case STT_SECTION:
1182 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1183 break;
1184 case STT_FILE:
1185 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1186 break;
1187 case STT_FUNC:
1188 sym->symbol.flags |= BSF_FUNCTION;
1189 break;
1190 case STT_OBJECT:
1191 sym->symbol.flags |= BSF_OBJECT;
1192 break;
1193 }
1194
1195 if (dynamic)
1196 sym->symbol.flags |= BSF_DYNAMIC;
1197
1198 if (x_versymp != NULL)
1199 {
1200 Elf_Internal_Versym iversym;
1201
1202 _bfd_elf_swap_versym_in (abfd, x_versymp + i, &iversym);
1203 sym->version = iversym.vs_vers;
1204 }
1205
1206 /* Do some backend-specific processing on this symbol. */
1207 {
1208 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1209 if (ebd->elf_backend_symbol_processing)
1210 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1211 }
1212
1213 sym++;
1214 }
1215 }
1216
1217 /* Do some backend-specific processing on this symbol table. */
1218 {
1219 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1220 if (ebd->elf_backend_symbol_table_processing)
1221 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1222 }
1223
1224 /* We rely on the zalloc to clear out the final symbol entry. */
1225
1226 symcount = sym - symbase;
1227
1228 /* Fill in the user's symbol pointer vector if needed. */
1229 if (symptrs)
1230 {
1231 long l = symcount;
1232
1233 sym = symbase;
1234 while (l-- > 0)
1235 {
1236 *symptrs++ = &sym->symbol;
1237 sym++;
1238 }
1239 *symptrs = 0; /* Final null pointer */
1240 }
1241
1242 if (x_versymp != NULL)
1243 free (x_versymp);
1244 if (x_symp != NULL)
1245 free (x_symp);
1246 return symcount;
1247error_return:
1248 if (x_versymp != NULL)
1249 free (x_versymp);
1250 if (x_symp != NULL)
1251 free (x_symp);
1252 return -1;
1253}
1254
1255/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
1256 them. */
1257
1258static boolean
1259elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1260 relents, symbols, dynamic)
1261 bfd *abfd;
1262 asection *asect;
1263 Elf_Internal_Shdr *rel_hdr;
1264 bfd_size_type reloc_count;
1265 arelent *relents;
1266 asymbol **symbols;
1267 boolean dynamic;
1268{
1269 struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
1270 PTR allocated = NULL;
1271 bfd_byte *native_relocs;
1272 arelent *relent;
1273 unsigned int i;
1274 int entsize;
1275
1276 allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size);
1277 if (allocated == NULL)
1278 goto error_return;
1279
1280 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
1281 || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd)
1282 != rel_hdr->sh_size))
1283 goto error_return;
1284
1285 native_relocs = (bfd_byte *) allocated;
1286
1287 entsize = rel_hdr->sh_entsize;
1288 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1289 || entsize == sizeof (Elf_External_Rela));
1290
1291 for (i = 0, relent = relents;
1292 i < reloc_count;
1293 i++, relent++, native_relocs += entsize)
1294 {
1295 Elf_Internal_Rela rela;
1296 Elf_Internal_Rel rel;
1297
1298 if (entsize == sizeof (Elf_External_Rela))
1299 elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1300 else
1301 {
1302 elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1303 rela.r_offset = rel.r_offset;
1304 rela.r_info = rel.r_info;
1305 rela.r_addend = 0;
1306 }
1307
1308 /* The address of an ELF reloc is section relative for an object
1309 file, and absolute for an executable file or shared library.
1310 The address of a normal BFD reloc is always section relative,
1311 and the address of a dynamic reloc is absolute.. */
1312 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1313 relent->address = rela.r_offset;
1314 else
1315 relent->address = rela.r_offset - asect->vma;
1316
1317 if (ELF_R_SYM (rela.r_info) == 0)
1318 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1319 else
1320 {
1321 asymbol **ps, *s;
1322
1323 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1324 s = *ps;
1325
1326 /* Canonicalize ELF section symbols. FIXME: Why? */
1327 if ((s->flags & BSF_SECTION_SYM) == 0)
1328 relent->sym_ptr_ptr = ps;
1329 else
1330 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1331 }
1332
1333 relent->addend = rela.r_addend;
1334
1335 if (entsize == sizeof (Elf_External_Rela))
1336 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1337 else
1338 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1339 }
1340
1341 if (allocated != NULL)
1342 free (allocated);
1343
1344 return true;
1345
1346 error_return:
1347 if (allocated != NULL)
1348 free (allocated);
1349 return false;
1350}
1351
1352/* Read in and swap the external relocs. */
1353
1354boolean
1355elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1356 bfd *abfd;
1357 asection *asect;
1358 asymbol **symbols;
1359 boolean dynamic;
1360{
1361 struct bfd_elf_section_data * const d = elf_section_data (asect);
1362 Elf_Internal_Shdr *rel_hdr;
1363 Elf_Internal_Shdr *rel_hdr2;
1364 bfd_size_type reloc_count;
1365 bfd_size_type reloc_count2;
1366 arelent *relents;
1367
1368 if (asect->relocation != NULL)
1369 return true;
1370
1371 if (! dynamic)
1372 {
1373 if ((asect->flags & SEC_RELOC) == 0
1374 || asect->reloc_count == 0)
1375 return true;
1376
1377 rel_hdr = &d->rel_hdr;
1378 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1379 rel_hdr2 = d->rel_hdr2;
1380 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
1381
1382 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1383 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1384 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1385
1386 }
1387 else
1388 {
1389 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1390 case because relocations against this section may use the
1391 dynamic symbol table, and in that case bfd_section_from_shdr
1392 in elf.c does not update the RELOC_COUNT. */
1393 if (asect->_raw_size == 0)
1394 return true;
1395
1396 rel_hdr = &d->this_hdr;
1397 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
1398 rel_hdr2 = NULL;
1399 reloc_count2 = 0;
1400 }
1401
1402 relents = ((arelent *)
1403 bfd_alloc (abfd,
1404 (reloc_count + reloc_count2) * sizeof (arelent)));
1405 if (relents == NULL)
1406 return false;
1407
1408 if (!elf_slurp_reloc_table_from_section (abfd, asect,
1409 rel_hdr, reloc_count,
1410 relents,
1411 symbols, dynamic))
1412 return false;
1413
1414 if (rel_hdr2
1415 && !elf_slurp_reloc_table_from_section (abfd, asect,
1416 rel_hdr2, reloc_count2,
1417 relents + reloc_count,
1418 symbols, dynamic))
1419 return false;
1420
1421 asect->relocation = relents;
1422 return true;
1423}
1424
1425#ifdef DEBUG
1426static void
1427elf_debug_section (num, hdr)
1428 int num;
1429 Elf_Internal_Shdr *hdr;
1430{
1431 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1432 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1433 (long) hdr);
1434 fprintf (stderr,
1435 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1436 (long) hdr->sh_name,
1437 (long) hdr->sh_type,
1438 (long) hdr->sh_flags);
1439 fprintf (stderr,
1440 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1441 (long) hdr->sh_addr,
1442 (long) hdr->sh_offset,
1443 (long) hdr->sh_size);
1444 fprintf (stderr,
1445 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1446 (long) hdr->sh_link,
1447 (long) hdr->sh_info,
1448 (long) hdr->sh_addralign);
1449 fprintf (stderr, "sh_entsize = %ld\n",
1450 (long) hdr->sh_entsize);
1451 fflush (stderr);
1452}
1453
1454static void
1455elf_debug_file (ehdrp)
1456 Elf_Internal_Ehdr *ehdrp;
1457{
1458 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1459 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1460 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1461 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1462 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1463 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1464 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1465}
1466
1467static char *
1468elf_symbol_flags (flags)
1469 flagword flags;
1470{
1471 static char buffer[1024];
1472
1473 buffer[0] = '\0';
1474 if (flags & BSF_LOCAL)
1475 strcat (buffer, " local");
1476
1477 if (flags & BSF_GLOBAL)
1478 strcat (buffer, " global");
1479
1480 if (flags & BSF_DEBUGGING)
1481 strcat (buffer, " debug");
1482
1483 if (flags & BSF_FUNCTION)
1484 strcat (buffer, " function");
1485
1486 if (flags & BSF_KEEP)
1487 strcat (buffer, " keep");
1488
1489 if (flags & BSF_KEEP_G)
1490 strcat (buffer, " keep_g");
1491
1492 if (flags & BSF_WEAK)
1493 strcat (buffer, " weak");
1494
1495 if (flags & BSF_SECTION_SYM)
1496 strcat (buffer, " section-sym");
1497
1498 if (flags & BSF_OLD_COMMON)
1499 strcat (buffer, " old-common");
1500
1501 if (flags & BSF_NOT_AT_END)
1502 strcat (buffer, " not-at-end");
1503
1504 if (flags & BSF_CONSTRUCTOR)
1505 strcat (buffer, " constructor");
1506
1507 if (flags & BSF_WARNING)
1508 strcat (buffer, " warning");
1509
1510 if (flags & BSF_INDIRECT)
1511 strcat (buffer, " indirect");
1512
1513 if (flags & BSF_FILE)
1514 strcat (buffer, " file");
1515
1516 if (flags & DYNAMIC)
1517 strcat (buffer, " dynamic");
1518
1519 if (flags & ~(BSF_LOCAL
1520 | BSF_GLOBAL
1521 | BSF_DEBUGGING
1522 | BSF_FUNCTION
1523 | BSF_KEEP
1524 | BSF_KEEP_G
1525 | BSF_WEAK
1526 | BSF_SECTION_SYM
1527 | BSF_OLD_COMMON
1528 | BSF_NOT_AT_END
1529 | BSF_CONSTRUCTOR
1530 | BSF_WARNING
1531 | BSF_INDIRECT
1532 | BSF_FILE
1533 | BSF_DYNAMIC))
1534 strcat (buffer, " unknown-bits");
1535
1536 return buffer;
1537}
1538#endif
1539
1540
1541#include "elfcore.h"
1542#include "elflink.h"
1543
1544
1545/* Size-dependent data and functions. */
1546const struct elf_size_info NAME(_bfd_elf,size_info) = {
1547 sizeof (Elf_External_Ehdr),
1548 sizeof (Elf_External_Phdr),
1549 sizeof (Elf_External_Shdr),
1550 sizeof (Elf_External_Rel),
1551 sizeof (Elf_External_Rela),
1552 sizeof (Elf_External_Sym),
1553 sizeof (Elf_External_Dyn),
1554 sizeof (Elf_External_Note),
1555 4,
1556 1,
1557 ARCH_SIZE, FILE_ALIGN,
1558 ELFCLASS, EV_CURRENT,
1559 elf_write_out_phdrs,
1560 elf_write_shdrs_and_ehdr,
1561 elf_write_relocs,
1562 elf_swap_symbol_out,
1563 elf_slurp_reloc_table,
1564 elf_slurp_symbol_table,
1565 elf_swap_dyn_in,
1566 elf_swap_dyn_out,
1567 NULL,
1568 NULL,
1569 NULL,
1570 NULL
1571};
Note: See TracBrowser for help on using the repository browser.