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