projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Touches most files in bfd/, so likely will be blamed for everything..
[deliverable/binutils-gdb.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
3e932841 571 /* If there is no section header table, we're hosed. */
252b5132
RH		 572 if (i_ehdrp->e_shoff == 0)
573 goto got_wrong_format_error;
574
575 /* As a simple sanity check, verify that the what BFD thinks is the
576 size of each section header table entry actually matches the size
3e932841 577 recorded in the file. */
252b5132
RH		 578 if (i_ehdrp->e_shentsize != sizeof (x_shdr))
579 goto got_wrong_format_error;
580
581 ebd = get_elf_backend_data (abfd);
582
583 /* Check that the ELF e_machine field matches what this particular
584 BFD format expects. */
585 if (ebd->elf_machine_code != i_ehdrp->e_machine
586 && (ebd->elf_machine_alt1 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt1)
587 && (ebd->elf_machine_alt2 == 0 || i_ehdrp->e_machine != ebd->elf_machine_alt2))
588 {
589 const bfd_target * const *target_ptr;
590
591 if (ebd->elf_machine_code != EM_NONE)
592 goto got_wrong_format_error;
593
594 /* This is the generic ELF target. Let it match any ELF target
595 for which we do not have a specific backend. */
596 for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
597 {
598 struct elf_backend_data *back;
599
600 if ((*target_ptr)->flavour != bfd_target_elf_flavour)
601 continue;
602 back = (struct elf_backend_data *) (*target_ptr)->backend_data;
603 if (back->elf_machine_code == i_ehdrp->e_machine
604 || (back->elf_machine_alt1 != 0
605 && back->elf_machine_alt1 == i_ehdrp->e_machine)
606 || (back->elf_machine_alt2 != 0
607 && back->elf_machine_alt2 == i_ehdrp->e_machine))
608 {
609 /* target_ptr is an ELF backend which matches this
610 object file, so reject the generic ELF target. */
611 goto got_wrong_format_error;
612 }
613 }
614 }
615
616 if (i_ehdrp->e_type == ET_EXEC)
617 abfd->flags |= EXEC_P;
618 else if (i_ehdrp->e_type == ET_DYN)
619 abfd->flags |= DYNAMIC;
620
621 if (i_ehdrp->e_phnum > 0)
622 abfd->flags |= D_PAGED;
623
624 if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
625 {
626 /* It's OK if this fails for the generic target. */
627 if (ebd->elf_machine_code != EM_NONE)
628 goto got_no_match;
629 }
630
3e932841 631 /* Remember the entry point specified in the ELF file header. */
448cafa4 632 bfd_set_start_address (abfd, i_ehdrp->e_entry);
252b5132
RH		 633
634 /* Allocate space for a copy of the section header table in
635 internal form, seek to the section header table in the file,
636 read it in, and convert it to internal form. */
dc810e39
AM		 637 amt = sizeof (*i_shdrp) * i_ehdrp->e_shnum;
638 i_shdrp = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
639 amt = sizeof (i_shdrp) * i_ehdrp->e_shnum;
640 elf_elfsections (abfd) = (Elf_Internal_Shdr **) bfd_alloc (abfd, amt);
252b5132
RH		 641 if (!i_shdrp || !elf_elfsections (abfd))
642 goto got_no_match;
dc810e39 643 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0)
252b5132
RH		 644 goto got_no_match;
645 for (shindex = 0; shindex < i_ehdrp->e_shnum; shindex++)
646 {
dc810e39
AM		 647 if (bfd_bread ((PTR) & x_shdr, (bfd_size_type) sizeof x_shdr, abfd)
648 != sizeof (x_shdr))
252b5132
RH		 649 goto got_no_match;
650 elf_swap_shdr_in (abfd, &x_shdr, i_shdrp + shindex);
651 elf_elfsections (abfd)[shindex] = i_shdrp + shindex;
652
653 /* If the section is loaded, but not page aligned, clear
654 D_PAGED. */
655 if ((i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
656 && i_shdrp[shindex].sh_type != SHT_NOBITS
657 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
658 % ebd->maxpagesize)
659 != 0))
660 abfd->flags &= ~D_PAGED;
661 }
662 if (i_ehdrp->e_shstrndx)
663 {
664 if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
665 goto got_no_match;
666 }
667
668 /* Read in the program headers. */
669 if (i_ehdrp->e_phnum == 0)
670 elf_tdata (abfd)->phdr = NULL;
671 else
672 {
673 Elf_Internal_Phdr *i_phdr;
674 unsigned int i;
675
dc810e39
AM		 676 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
677 elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
252b5132
RH		 678 if (elf_tdata (abfd)->phdr == NULL)
679 goto got_no_match;
dc810e39 680 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
252b5132
RH		 681 goto got_no_match;
682 i_phdr = elf_tdata (abfd)->phdr;
683 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
684 {
685 Elf_External_Phdr x_phdr;
686
dc810e39 687 if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof x_phdr, abfd)
252b5132
RH		 688 != sizeof x_phdr)
689 goto got_no_match;
690 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
691 }
692 }
693
694 /* Read in the string table containing the names of the sections. We
3e932841 695 will need the base pointer to this table later. */
252b5132
RH		 696 /* We read this inline now, so that we don't have to go through
697 bfd_section_from_shdr with it (since this particular strtab is
698 used to find all of the ELF section names.) */
699
700 shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
701 if (!shstrtab)
702 goto got_no_match;
703
704 /* Once all of the section headers have been read and converted, we
705 can start processing them. Note that the first section header is
706 a dummy placeholder entry, so we ignore it. */
707
708 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
709 {
710 if (! bfd_section_from_shdr (abfd, shindex))
711 goto got_no_match;
712 }
713
714 /* Let the backend double check the format and override global
715 information. */
716 if (ebd->elf_backend_object_p)
717 {
718 if ((*ebd->elf_backend_object_p) (abfd) == false)
719 goto got_wrong_format_error;
720 }
721
722 /* If we have created any reloc sections that are associated with
723 debugging sections, mark the reloc sections as debugging as well. */
724 for (s = abfd->sections; s != NULL; s = s->next)
725 {
726 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
727 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
728 && elf_section_data (s)->this_hdr.sh_info > 0)
729 {
730 unsigned long targ_index;
731 asection *targ_sec;
732
733 targ_index = elf_section_data (s)->this_hdr.sh_info;
734 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
735 if (targ_sec != NULL
736 && (targ_sec->flags & SEC_DEBUGGING) != 0)
737 s->flags |= SEC_DEBUGGING;
738 }
739 }
740
741 return (abfd->xvec);
742
743 got_wrong_format_error:
a77a9fef
HPN		 744 /* There is way too much undoing of half-known state here. The caller,
745 bfd_check_format_matches, really shouldn't iterate on live bfd's to
746 check match/no-match like it does. We have to rely on that a call to
747 bfd_default_set_arch_mach with the previously known mach, undoes what
748 was done by the first bfd_default_set_arch_mach (with mach 0) here.
749 For this to work, only elf-data and the mach may be changed by the
750 target-specific elf_backend_object_p function. Note that saving the
751 whole bfd here and restoring it would be even worse; the first thing
752 you notice is that the cached bfd file position gets out of sync. */
753 bfd_default_set_arch_mach (abfd, previous_arch, previous_mach);
252b5132
RH		 754 bfd_set_error (bfd_error_wrong_format);
755 got_no_match:
756 if (new_tdata != NULL
757 && new_tdata->elf_sect_ptr != NULL)
758 bfd_release (abfd, new_tdata->elf_sect_ptr);
759 if (i_shdrp != NULL)
760 bfd_release (abfd, i_shdrp);
761 if (new_tdata != NULL)
762 bfd_release (abfd, new_tdata);
763 elf_tdata (abfd) = preserved_tdata;
a17cc40f
HPN		 764 abfd->sections = preserved_sections;
765 abfd->section_count = preserved_section_count;
252b5132
RH		 766 return (NULL);
767}
768\f
769/* ELF .o/exec file writing */
770
771/* Write out the relocs. */
772
b9f66672
JL		 773void
774elf_write_relocs (abfd, sec, data)
252b5132
RH		 775 bfd *abfd;
776 asection *sec;
777 PTR data;
778{
779 boolean *failedp = (boolean *) data;
780 Elf_Internal_Shdr *rela_hdr;
781 Elf_External_Rela *outbound_relocas;
782 Elf_External_Rel *outbound_relocs;
783 unsigned int idx;
bf572ba0 784 int use_rela_p;
252b5132
RH		 785 asymbol *last_sym = 0;
786 int last_sym_idx = 0;
787
788 /* If we have already failed, don't do anything. */
789 if (*failedp)
790 return;
791
792 if ((sec->flags & SEC_RELOC) == 0)
793 return;
794
795 /* The linker backend writes the relocs out itself, and sets the
796 reloc_count field to zero to inhibit writing them here. Also,
797 sometimes the SEC_RELOC flag gets set even when there aren't any
798 relocs. */
799 if (sec->reloc_count == 0)
800 return;
801
802 rela_hdr = &elf_section_data (sec)->rel_hdr;
803
804 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
805 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
806 if (rela_hdr->contents == NULL)
807 {
808 *failedp = true;
809 return;
810 }
811
bf572ba0
MM		 812 /* Figure out whether the relocations are RELA or REL relocations. */
813 if (rela_hdr->sh_type == SHT_RELA)
814 use_rela_p = true;
815 else if (rela_hdr->sh_type == SHT_REL)
816 use_rela_p = false;
817 else
818 /* Every relocation section should be either an SHT_RELA or an
819 SHT_REL section. */
820 abort ();
821
3e932841 822 /* orelocation has the data, reloc_count has the count... */
252b5132
RH		 823 if (use_rela_p)
824 {
825 outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
826
827 for (idx = 0; idx < sec->reloc_count; idx++)
828 {
829 Elf_Internal_Rela dst_rela;
830 Elf_External_Rela *src_rela;
831 arelent *ptr;
832 asymbol *sym;
833 int n;
834
835 ptr = sec->orelocation[idx];
836 src_rela = outbound_relocas + idx;
837
838 /* The address of an ELF reloc is section relative for an object
839 file, and absolute for an executable file or shared library.
840 The address of a BFD reloc is always section relative. */
841 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
842 dst_rela.r_offset = ptr->address;
843 else
844 dst_rela.r_offset = ptr->address + sec->vma;
845
846 sym = *ptr->sym_ptr_ptr;
847 if (sym == last_sym)
848 n = last_sym_idx;
849 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
850 n = STN_UNDEF;
851 else
852 {
853 last_sym = sym;
854 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
855 if (n < 0)
856 {
857 *failedp = true;
858 return;
859 }
860 last_sym_idx = n;
861 }
862
863 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
864 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
865 && ! _bfd_elf_validate_reloc (abfd, ptr))
866 {
867 *failedp = true;
868 return;
869 }
870
871 dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
872
873 dst_rela.r_addend = ptr->addend;
874 elf_swap_reloca_out (abfd, &dst_rela, src_rela);
875 }
876 }
877 else
878 /* REL relocations */
879 {
880 outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
881
882 for (idx = 0; idx < sec->reloc_count; idx++)
883 {
884 Elf_Internal_Rel dst_rel;
885 Elf_External_Rel *src_rel;
886 arelent *ptr;
887 int n;
888 asymbol *sym;
889
890 ptr = sec->orelocation[idx];
891 sym = *ptr->sym_ptr_ptr;
892 src_rel = outbound_relocs + idx;
893
894 /* The address of an ELF reloc is section relative for an object
895 file, and absolute for an executable file or shared library.
896 The address of a BFD reloc is always section relative. */
897 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
898 dst_rel.r_offset = ptr->address;
899 else
900 dst_rel.r_offset = ptr->address + sec->vma;
901
902 if (sym == last_sym)
903 n = last_sym_idx;
eeaf533e
ILT		 904 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
905 n = STN_UNDEF;
252b5132
RH		 906 else
907 {
908 last_sym = sym;
909 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
910 if (n < 0)
911 {
912 *failedp = true;
913 return;
914 }
915 last_sym_idx = n;
916 }
917
2f66722d
AM		 918 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
919 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
252b5132
RH		 920 && ! _bfd_elf_validate_reloc (abfd, ptr))
921 {
922 *failedp = true;
923 return;
924 }
925
926 dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
927
928 elf_swap_reloc_out (abfd, &dst_rel, src_rel);
929 }
930 }
931}
932
933/* Write out the program headers. */
934
935int
936elf_write_out_phdrs (abfd, phdr, count)
937 bfd *abfd;
938 const Elf_Internal_Phdr *phdr;
dc810e39 939 unsigned int count;
252b5132
RH		 940{
941 while (count--)
942 {
943 Elf_External_Phdr extphdr;
944 elf_swap_phdr_out (abfd, phdr, &extphdr);
dc810e39
AM		 945 if (bfd_bwrite (&extphdr, (bfd_size_type) sizeof (Elf_External_Phdr),
946 abfd) != sizeof (Elf_External_Phdr))
252b5132
RH		 947 return -1;
948 phdr++;
949 }
950 return 0;
951}
952
953/* Write out the section headers and the ELF file header. */
954
955boolean
956elf_write_shdrs_and_ehdr (abfd)
957 bfd *abfd;
958{
959 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
960 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
961 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
962 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
963 unsigned int count;
dc810e39 964 bfd_size_type amt;
252b5132
RH		 965
966 i_ehdrp = elf_elfheader (abfd);
967 i_shdrp = elf_elfsections (abfd);
968
3e932841 969 /* swap the header before spitting it out... */
252b5132
RH		 970
971#if DEBUG & 1
972 elf_debug_file (i_ehdrp);
973#endif
974 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
dc810e39 975 amt = sizeof (x_ehdr);
252b5132 976 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
dc810e39 977 || bfd_bwrite ((PTR) & x_ehdr, amt, abfd) != amt)
252b5132
RH		 978 return false;
979
3e932841 980 /* at this point we've concocted all the ELF sections... */
dc810e39
AM		 981 amt = sizeof (*x_shdrp) * i_ehdrp->e_shnum;
982 x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
252b5132
RH		 983 if (!x_shdrp)
984 return false;
985
986 for (count = 0; count < i_ehdrp->e_shnum; count++)
987 {
988#if DEBUG & 2
989 elf_debug_section (count, i_shdrp[count]);
990#endif
991 elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
992 }
dc810e39
AM		 993 amt = i_ehdrp->e_shnum;
994 amt *= sizeof (*x_shdrp);
252b5132 995 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
dc810e39 996 || bfd_bwrite ((PTR) x_shdrp, amt, abfd) != amt)
252b5132
RH		 997 return false;
998
3e932841 999 /* need to dump the string table too... */
252b5132
RH		 1000
1001 return true;
1002}
1003
1004long
1005elf_slurp_symbol_table (abfd, symptrs, dynamic)
1006 bfd *abfd;
1007 asymbol **symptrs; /* Buffer for generated bfd symbols */
1008 boolean dynamic;
1009{
1010 Elf_Internal_Shdr *hdr;
1011 Elf_Internal_Shdr *verhdr;
1012 unsigned long symcount; /* Number of external ELF symbols */
1013 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1014 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1015 Elf_Internal_Sym i_sym;
1016 Elf_External_Sym *x_symp = NULL;
1017 Elf_External_Versym *x_versymp = NULL;
dc810e39 1018 bfd_size_type amt;
252b5132
RH		 1019
1020 /* Read each raw ELF symbol, converting from external ELF form to
1021 internal ELF form, and then using the information to create a
1022 canonical bfd symbol table entry.
1023
1024 Note that we allocate the initial bfd canonical symbol buffer
1025 based on a one-to-one mapping of the ELF symbols to canonical
1026 symbols. We actually use all the ELF symbols, so there will be no
1027 space left over at the end. When we have all the symbols, we
3e932841 1028 build the caller's pointer vector. */
252b5132
RH		 1029
1030 if (! dynamic)
1031 {
1032 hdr = &elf_tdata (abfd)->symtab_hdr;
1033 verhdr = NULL;
1034 }
1035 else
1036 {
1037 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1038 if (elf_dynversym (abfd) == 0)
1039 verhdr = NULL;
1040 else
1041 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1042 if ((elf_tdata (abfd)->dynverdef_section != 0
1043 && elf_tdata (abfd)->verdef == NULL)
1044 || (elf_tdata (abfd)->dynverref_section != 0
1045 && elf_tdata (abfd)->verref == NULL))
1046 {
1047 if (! _bfd_elf_slurp_version_tables (abfd))
1048 return -1;
1049 }
1050 }
1051
dc810e39 1052 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0)
252b5132
RH		 1053 return -1;
1054
1055 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1056
1057 if (symcount == 0)
1058 sym = symbase = NULL;
1059 else
1060 {
1061 unsigned long i;
1062
dc810e39 1063 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0)
252b5132
RH		 1064 return -1;
1065
dc810e39
AM		 1066 amt = symcount;
1067 amt *= sizeof (elf_symbol_type);
1068 symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
252b5132
RH		 1069 if (symbase == (elf_symbol_type *) NULL)
1070 return -1;
1071 sym = symbase;
1072
1073 /* Temporarily allocate room for the raw ELF symbols. */
dc810e39
AM		 1074 amt = symcount;
1075 amt *= sizeof (Elf_External_Sym);
1076 x_symp = (Elf_External_Sym *) bfd_malloc (amt);
252b5132
RH		 1077 if (x_symp == NULL && symcount != 0)
1078 goto error_return;
1079
dc810e39
AM		 1080 if (bfd_bread ((PTR) x_symp,
1081 (bfd_size_type) (symcount * sizeof (Elf_External_Sym)),
1082 abfd)
252b5132
RH		 1083 != symcount * sizeof (Elf_External_Sym))
1084 goto error_return;
1085
1086 /* Read the raw ELF version symbol information. */
1087
1088 if (verhdr != NULL
1089 && verhdr->sh_size / sizeof (Elf_External_Versym) != symcount)
1090 {
1091 (*_bfd_error_handler)
1092 (_("%s: version count (%ld) does not match symbol count (%ld)"),
1093 abfd->filename,
1094 (long) (verhdr->sh_size / sizeof (Elf_External_Versym)),
1095 symcount);
1096
1097 /* Slurp in the symbols without the version information,
1098 since that is more helpful than just quitting. */
1099 verhdr = NULL;
1100 }
1101
1102 if (verhdr != NULL)
1103 {
1104 if (bfd_seek (abfd, verhdr->sh_offset, SEEK_SET) != 0)
1105 goto error_return;
1106
1107 x_versymp = (Elf_External_Versym *) bfd_malloc (verhdr->sh_size);
1108 if (x_versymp == NULL && verhdr->sh_size != 0)
1109 goto error_return;
1110
dc810e39 1111 if (bfd_bread ((PTR) x_versymp, (bfd_size_type) verhdr->sh_size, abfd)
252b5132
RH		 1112 != verhdr->sh_size)
1113 goto error_return;
1114 }
1115
1116 /* Skip first symbol, which is a null dummy. */
1117 for (i = 1; i < symcount; i++)
1118 {
1119 elf_swap_symbol_in (abfd, x_symp + i, &i_sym);
1120 memcpy (&sym->internal_elf_sym, &i_sym, sizeof (Elf_Internal_Sym));
1121#ifdef ELF_KEEP_EXTSYM
1122 memcpy (&sym->native_elf_sym, x_symp + i, sizeof (Elf_External_Sym));
1123#endif
1124 sym->symbol.the_bfd = abfd;
1125
1126 sym->symbol.name = bfd_elf_string_from_elf_section (abfd,
1127 hdr->sh_link,
1128 i_sym.st_name);
1129
1130 sym->symbol.value = i_sym.st_value;
1131
1132 if (i_sym.st_shndx > 0 && i_sym.st_shndx < SHN_LORESERVE)
1133 {
1134 sym->symbol.section = section_from_elf_index (abfd,
1135 i_sym.st_shndx);
1136 if (sym->symbol.section == NULL)
1137 {
1138 /* This symbol is in a section for which we did not
1139 create a BFD section. Just use bfd_abs_section,
1140 although it is wrong. FIXME. */
1141 sym->symbol.section = bfd_abs_section_ptr;
1142 }
1143 }
1144 else if (i_sym.st_shndx == SHN_ABS)
1145 {
1146 sym->symbol.section = bfd_abs_section_ptr;
1147 }
1148 else if (i_sym.st_shndx == SHN_COMMON)
1149 {
1150 sym->symbol.section = bfd_com_section_ptr;
1151 /* Elf puts the alignment into the `value' field, and
1152 the size into the `size' field. BFD wants to see the
1153 size in the value field, and doesn't care (at the
1154 moment) about the alignment. */
1155 sym->symbol.value = i_sym.st_size;
1156 }
1157 else if (i_sym.st_shndx == SHN_UNDEF)
1158 {
1159 sym->symbol.section = bfd_und_section_ptr;
1160 }
1161 else
1162 sym->symbol.section = bfd_abs_section_ptr;
1163
1164 /* If this is a relocateable file, then the symbol value is
1165 already section relative. */
1166 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
1167 sym->symbol.value -= sym->symbol.section->vma;
1168
1169 switch (ELF_ST_BIND (i_sym.st_info))
1170 {
1171 case STB_LOCAL:
1172 sym->symbol.flags |= BSF_LOCAL;
1173 break;
1174 case STB_GLOBAL:
1175 if (i_sym.st_shndx != SHN_UNDEF
1176 && i_sym.st_shndx != SHN_COMMON)
1177 sym->symbol.flags |= BSF_GLOBAL;
1178 break;
1179 case STB_WEAK:
1180 sym->symbol.flags |= BSF_WEAK;
1181 break;
1182 }
1183
1184 switch (ELF_ST_TYPE (i_sym.st_info))
1185 {
1186 case STT_SECTION:
1187 sym->symbol.flags |= BSF_SECTION_SYM | BSF_DEBUGGING;
1188 break;
1189 case STT_FILE:
1190 sym->symbol.flags |= BSF_FILE | BSF_DEBUGGING;
1191 break;
1192 case STT_FUNC:
1193 sym->symbol.flags |= BSF_FUNCTION;
1194 break;
1195 case STT_OBJECT:
1196 sym->symbol.flags |= BSF_OBJECT;
1197 break;
1198 }
1199
1200 if (dynamic)
1201 sym->symbol.flags |= BSF_DYNAMIC;
1202
1203 if (x_versymp != NULL)
1204 {
1205 Elf_Internal_Versym iversym;
1206
1207 _bfd_elf_swap_versym_in (abfd, x_versymp + i, &iversym);
1208 sym->version = iversym.vs_vers;
1209 }
1210
1211 /* Do some backend-specific processing on this symbol. */
1212 {
1213 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1214 if (ebd->elf_backend_symbol_processing)
1215 (*ebd->elf_backend_symbol_processing) (abfd, &sym->symbol);
1216 }
1217
1218 sym++;
1219 }
1220 }
1221
1222 /* Do some backend-specific processing on this symbol table. */
1223 {
1224 struct elf_backend_data *ebd = get_elf_backend_data (abfd);
1225 if (ebd->elf_backend_symbol_table_processing)
1226 (*ebd->elf_backend_symbol_table_processing) (abfd, symbase, symcount);
1227 }
1228
1229 /* We rely on the zalloc to clear out the final symbol entry. */
1230
1231 symcount = sym - symbase;
1232
1233 /* Fill in the user's symbol pointer vector if needed. */
1234 if (symptrs)
1235 {
1236 long l = symcount;
1237
1238 sym = symbase;
1239 while (l-- > 0)
1240 {
1241 *symptrs++ = &sym->symbol;
1242 sym++;
1243 }
1244 *symptrs = 0; /* Final null pointer */
1245 }
1246
1247 if (x_versymp != NULL)
1248 free (x_versymp);
1249 if (x_symp != NULL)
1250 free (x_symp);
1251 return symcount;
1252error_return:
1253 if (x_versymp != NULL)
1254 free (x_versymp);
1255 if (x_symp != NULL)
1256 free (x_symp);
1257 return -1;
1258}
1259
60bcf0fa 1260/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
42fdc509 1261 them. */
252b5132
RH		 1262
1263static boolean
42fdc509
MM		 1264elf_slurp_reloc_table_from_section (abfd, asect, rel_hdr, reloc_count,
1265 relents, symbols, dynamic)
252b5132
RH		 1266 bfd *abfd;
1267 asection *asect;
42fdc509
MM		 1268 Elf_Internal_Shdr *rel_hdr;
1269 bfd_size_type reloc_count;
1270 arelent *relents;
252b5132
RH		 1271 asymbol **symbols;
1272 boolean dynamic;
1273{
1274 struct elf_backend_data * const ebd = get_elf_backend_data (abfd);
252b5132
RH		 1275 PTR allocated = NULL;
1276 bfd_byte *native_relocs;
252b5132
RH		 1277 arelent *relent;
1278 unsigned int i;
1279 int entsize;
1280
dc810e39 1281 allocated = (PTR) bfd_malloc (rel_hdr->sh_size);
252b5132
RH		 1282 if (allocated == NULL)
1283 goto error_return;
1284
1285 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
dc810e39 1286 || (bfd_bread (allocated, rel_hdr->sh_size, abfd)
252b5132
RH		 1287 != rel_hdr->sh_size))
1288 goto error_return;
1289
1290 native_relocs = (bfd_byte *) allocated;
1291
252b5132
RH		 1292 entsize = rel_hdr->sh_entsize;
1293 BFD_ASSERT (entsize == sizeof (Elf_External_Rel)
1294 || entsize == sizeof (Elf_External_Rela));
1295
1296 for (i = 0, relent = relents;
1297 i < reloc_count;
1298 i++, relent++, native_relocs += entsize)
1299 {
1300 Elf_Internal_Rela rela;
1301 Elf_Internal_Rel rel;
1302
1303 if (entsize == sizeof (Elf_External_Rela))
1304 elf_swap_reloca_in (abfd, (Elf_External_Rela *) native_relocs, &rela);
1305 else
1306 {
1307 elf_swap_reloc_in (abfd, (Elf_External_Rel *) native_relocs, &rel);
1308 rela.r_offset = rel.r_offset;
1309 rela.r_info = rel.r_info;
1310 rela.r_addend = 0;
1311 }
1312
1313 /* The address of an ELF reloc is section relative for an object
1314 file, and absolute for an executable file or shared library.
1315 The address of a normal BFD reloc is always section relative,
1316 and the address of a dynamic reloc is absolute.. */
1317 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
1318 relent->address = rela.r_offset;
1319 else
1320 relent->address = rela.r_offset - asect->vma;
1321
1322 if (ELF_R_SYM (rela.r_info) == 0)
1323 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
1324 else
1325 {
1326 asymbol **ps, *s;
1327
1328 ps = symbols + ELF_R_SYM (rela.r_info) - 1;
1329 s = *ps;
1330
1331 /* Canonicalize ELF section symbols. FIXME: Why? */
1332 if ((s->flags & BSF_SECTION_SYM) == 0)
1333 relent->sym_ptr_ptr = ps;
1334 else
1335 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
1336 }
1337
1338 relent->addend = rela.r_addend;
1339
1340 if (entsize == sizeof (Elf_External_Rela))
1341 (*ebd->elf_info_to_howto) (abfd, relent, &rela);
1342 else
1343 (*ebd->elf_info_to_howto_rel) (abfd, relent, &rel);
1344 }
1345
252b5132
RH		 1346 if (allocated != NULL)
1347 free (allocated);
1348
1349 return true;
1350
1351 error_return:
1352 if (allocated != NULL)
1353 free (allocated);
1354 return false;
1355}
1356
42fdc509
MM		 1357/* Read in and swap the external relocs. */
1358
b9f66672 1359boolean
42fdc509
MM		 1360elf_slurp_reloc_table (abfd, asect, symbols, dynamic)
1361 bfd *abfd;
1362 asection *asect;
1363 asymbol **symbols;
1364 boolean dynamic;
1365{
1366 struct bfd_elf_section_data * const d = elf_section_data (asect);
1367 Elf_Internal_Shdr *rel_hdr;
1368 Elf_Internal_Shdr *rel_hdr2;
1369 bfd_size_type reloc_count;
1370 bfd_size_type reloc_count2;
1371 arelent *relents;
dc810e39 1372 bfd_size_type amt;
42fdc509
MM		 1373
1374 if (asect->relocation != NULL)
1375 return true;
1376
1377 if (! dynamic)
1378 {
1379 if ((asect->flags & SEC_RELOC) == 0
1380 || asect->reloc_count == 0)
1381 return true;
1382
1383 rel_hdr = &d->rel_hdr;
d9bc7a44 1384 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
42fdc509 1385 rel_hdr2 = d->rel_hdr2;
d9bc7a44 1386 reloc_count2 = (rel_hdr2 ? NUM_SHDR_ENTRIES (rel_hdr2) : 0);
42fdc509
MM		 1387
1388 BFD_ASSERT (asect->reloc_count == reloc_count + reloc_count2);
1389 BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset
1390 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
1391
1392 }
1393 else
1394 {
57e21bef
MM		 1395 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
1396 case because relocations against this section may use the
1397 dynamic symbol table, and in that case bfd_section_from_shdr
1398 in elf.c does not update the RELOC_COUNT. */
42fdc509
MM		 1399 if (asect->_raw_size == 0)
1400 return true;
1401
1402 rel_hdr = &d->this_hdr;
d9bc7a44 1403 reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
42fdc509 1404 rel_hdr2 = NULL;
57e21bef 1405 reloc_count2 = 0;
42fdc509
MM		 1406 }
1407
dc810e39
AM		 1408 amt = (reloc_count + reloc_count2) * sizeof (arelent);
1409 relents = (arelent *) bfd_alloc (abfd, amt);
42fdc509
MM		 1410 if (relents == NULL)
1411 return false;
1412
1413 if (!elf_slurp_reloc_table_from_section (abfd, asect,
1414 rel_hdr, reloc_count,
1415 relents,
1416 symbols, dynamic))
1417 return false;
60bcf0fa
NC		 1418
1419 if (rel_hdr2
42fdc509
MM		 1420 && !elf_slurp_reloc_table_from_section (abfd, asect,
1421 rel_hdr2, reloc_count2,
1422 relents + reloc_count,
1423 symbols, dynamic))
1424 return false;
1425
42fdc509
MM		 1426 asect->relocation = relents;
1427 return true;
1428}
1429
252b5132
RH		 1430#ifdef DEBUG
1431static void
1432elf_debug_section (num, hdr)
1433 int num;
1434 Elf_Internal_Shdr *hdr;
1435{
1436 fprintf (stderr, "\nSection#%d '%s' 0x%.8lx\n", num,
1437 hdr->bfd_section != NULL ? hdr->bfd_section->name : "",
1438 (long) hdr);
1439 fprintf (stderr,
1440 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
1441 (long) hdr->sh_name,
1442 (long) hdr->sh_type,
1443 (long) hdr->sh_flags);
1444 fprintf (stderr,
1445 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
1446 (long) hdr->sh_addr,
1447 (long) hdr->sh_offset,
1448 (long) hdr->sh_size);
1449 fprintf (stderr,
1450 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
1451 (long) hdr->sh_link,
1452 (long) hdr->sh_info,
1453 (long) hdr->sh_addralign);
1454 fprintf (stderr, "sh_entsize = %ld\n",
1455 (long) hdr->sh_entsize);
1456 fflush (stderr);
1457}
1458
1459static void
1460elf_debug_file (ehdrp)
1461 Elf_Internal_Ehdr *ehdrp;
1462{
1463 fprintf (stderr, "e_entry = 0x%.8lx\n", (long) ehdrp->e_entry);
1464 fprintf (stderr, "e_phoff = %ld\n", (long) ehdrp->e_phoff);
1465 fprintf (stderr, "e_phnum = %ld\n", (long) ehdrp->e_phnum);
1466 fprintf (stderr, "e_phentsize = %ld\n", (long) ehdrp->e_phentsize);
1467 fprintf (stderr, "e_shoff = %ld\n", (long) ehdrp->e_shoff);
1468 fprintf (stderr, "e_shnum = %ld\n", (long) ehdrp->e_shnum);
1469 fprintf (stderr, "e_shentsize = %ld\n", (long) ehdrp->e_shentsize);
1470}
1471
1472static char *
1473elf_symbol_flags (flags)
1474 flagword flags;
1475{
1476 static char buffer[1024];
1477
1478 buffer[0] = '\0';
1479 if (flags & BSF_LOCAL)
1480 strcat (buffer, " local");
1481
1482 if (flags & BSF_GLOBAL)
1483 strcat (buffer, " global");
1484
1485 if (flags & BSF_DEBUGGING)
1486 strcat (buffer, " debug");
1487
1488 if (flags & BSF_FUNCTION)
1489 strcat (buffer, " function");
1490
1491 if (flags & BSF_KEEP)
1492 strcat (buffer, " keep");
1493
1494 if (flags & BSF_KEEP_G)
1495 strcat (buffer, " keep_g");
1496
1497 if (flags & BSF_WEAK)
1498 strcat (buffer, " weak");
1499
1500 if (flags & BSF_SECTION_SYM)
1501 strcat (buffer, " section-sym");
1502
1503 if (flags & BSF_OLD_COMMON)
1504 strcat (buffer, " old-common");
1505
1506 if (flags & BSF_NOT_AT_END)
1507 strcat (buffer, " not-at-end");
1508
1509 if (flags & BSF_CONSTRUCTOR)
1510 strcat (buffer, " constructor");
1511
1512 if (flags & BSF_WARNING)
1513 strcat (buffer, " warning");
1514
1515 if (flags & BSF_INDIRECT)
1516 strcat (buffer, " indirect");
1517
1518 if (flags & BSF_FILE)
1519 strcat (buffer, " file");
1520
1521 if (flags & DYNAMIC)
1522 strcat (buffer, " dynamic");
1523
1524 if (flags & ~(BSF_LOCAL
1525 | BSF_GLOBAL
1526 | BSF_DEBUGGING
1527 | BSF_FUNCTION
1528 | BSF_KEEP
1529 | BSF_KEEP_G
1530 | BSF_WEAK
1531 | BSF_SECTION_SYM
1532 | BSF_OLD_COMMON
1533 | BSF_NOT_AT_END
1534 | BSF_CONSTRUCTOR
1535 | BSF_WARNING
1536 | BSF_INDIRECT
1537 | BSF_FILE
1538 | BSF_DYNAMIC))
1539 strcat (buffer, " unknown-bits");
1540
1541 return buffer;
1542}
1543#endif
1544\f
1545#include "elfcore.h"
1546#include "elflink.h"
1547\f
1548/* Size-dependent data and functions. */
1549const struct elf_size_info NAME(_bfd_elf,size_info) = {
1550 sizeof (Elf_External_Ehdr),
1551 sizeof (Elf_External_Phdr),
1552 sizeof (Elf_External_Shdr),
1553 sizeof (Elf_External_Rel),
1554 sizeof (Elf_External_Rela),
1555 sizeof (Elf_External_Sym),
1556 sizeof (Elf_External_Dyn),
1557 sizeof (Elf_External_Note),
70bcb145 1558 4,
c7ac6ff8 1559 1,
252b5132
RH		 1560 ARCH_SIZE, FILE_ALIGN,
1561 ELFCLASS, EV_CURRENT,
1562 elf_write_out_phdrs,
1563 elf_write_shdrs_and_ehdr,
b9f66672 1564 elf_write_relocs,
252b5132
RH		 1565 elf_swap_symbol_out,
1566 elf_slurp_reloc_table,
1567 elf_slurp_symbol_table,
c7ac6ff8
MM		 1568 elf_swap_dyn_in,
1569 elf_swap_dyn_out,
1570 NULL,
1571 NULL,
1572 NULL,
1573 NULL
252b5132 1574};
GDB Binutils - Deliverables
This page took 0.163877 seconds and 4 git commands to generate.