source: branches/libc-0.6/src/binutils/bfd/elfcode.h

Last change on this file was 610, checked in by bird, 22 years ago

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