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