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