projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* section.c (struct sec): Remove kept_section.
[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. */
659 if ((i_shdrp[shindex].sh_flags & SHF_ALLOC) != 0
660 && i_shdrp[shindex].sh_type != SHT_NOBITS
661 && (((i_shdrp[shindex].sh_addr - i_shdrp[shindex].sh_offset)
662 % ebd->maxpagesize)
663 != 0))
664 abfd->flags &= ~D_PAGED;
665 }
666 if (i_ehdrp->e_shstrndx)
667 {
668 if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
669 goto got_no_match;
670 }
671
672 /* Read in the program headers. */
673 if (i_ehdrp->e_phnum == 0)
674 elf_tdata (abfd)->phdr = NULL;
675 else
676 {
677 Elf_Internal_Phdr *i_phdr;
678 unsigned int i;
679
dc810e39
AM		 680 amt = i_ehdrp->e_phnum * sizeof (Elf_Internal_Phdr);
681 elf_tdata (abfd)->phdr = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
252b5132
RH		 682 if (elf_tdata (abfd)->phdr == NULL)
683 goto got_no_match;
dc810e39 684 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
252b5132
RH		 685 goto got_no_match;
686 i_phdr = elf_tdata (abfd)->phdr;
687 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
688 {
689 Elf_External_Phdr x_phdr;
690
dc810e39 691 if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof x_phdr, abfd)
252b5132
RH		 692 != sizeof x_phdr)
693 goto got_no_match;
694 elf_swap_phdr_in (abfd, &x_phdr, i_phdr);
695 }
696 }
697
698 /* Read in the string table containing the names of the sections. We
3e932841 699 will need the base pointer to this table later. */
252b5132
RH		 700 /* We read this inline now, so that we don't have to go through
701 bfd_section_from_shdr with it (since this particular strtab is
702 used to find all of the ELF section names.) */
703
0c35f01a 704 if (i_ehdrp->e_shstrndx != 0)
252b5132 705 {
0c35f01a
AM		 706 shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
707 if (!shstrtab)
252b5132 708 goto got_no_match;
0c35f01a
AM		 709
710 /* Once all of the section headers have been read and converted, we
711 can start processing them. Note that the first section header is
712 a dummy placeholder entry, so we ignore it. */
713
714 for (shindex = 1; shindex < i_ehdrp->e_shnum; shindex++)
715 {
716 if (! bfd_section_from_shdr (abfd, shindex))
717 goto got_no_match;
718 }
252b5132
RH		 719 }
720
721 /* Let the backend double check the format and override global
722 information. */
723 if (ebd->elf_backend_object_p)
724 {
725 if ((*ebd->elf_backend_object_p) (abfd) == false)
726 goto got_wrong_format_error;
727 }
728
729 /* If we have created any reloc sections that are associated with
730 debugging sections, mark the reloc sections as debugging as well. */
731 for (s = abfd->sections; s != NULL; s = s->next)
732 {
733 if ((elf_section_data (s)->this_hdr.sh_type == SHT_REL
734 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA)
735 && elf_section_data (s)->this_hdr.sh_info > 0)
736 {
737 unsigned long targ_index;
738 asection *targ_sec;
739
740 targ_index = elf_section_data (s)->this_hdr.sh_info;
741 targ_sec = bfd_section_from_elf_index (abfd, targ_index);
742 if (targ_sec != NULL
743 && (targ_sec->flags & SEC_DEBUGGING) != 0)
744 s->flags |= SEC_DEBUGGING;
745 }
746 }
747
748 return (abfd->xvec);
749
750 got_wrong_format_error:
a77a9fef
HPN		 751 /* There is way too much undoing of half-known state here. The caller,
752 bfd_check_format_matches, really shouldn't iterate on live bfd's to
753 check match/no-match like it does. We have to rely on that a call to
754 bfd_default_set_arch_mach with the previously known mach, undoes what
755 was done by the first bfd_default_set_arch_mach (with mach 0) here.
756 For this to work, only elf-data and the mach may be changed by the
757 target-specific elf_backend_object_p function. Note that saving the
758 whole bfd here and restoring it would be even worse; the first thing
759 you notice is that the cached bfd file position gets out of sync. */
760 bfd_default_set_arch_mach (abfd, previous_arch, previous_mach);
252b5132
RH		 761 bfd_set_error (bfd_error_wrong_format);
762 got_no_match:
763 if (new_tdata != NULL
764 && new_tdata->elf_sect_ptr != NULL)
765 bfd_release (abfd, new_tdata->elf_sect_ptr);
766 if (i_shdrp != NULL)
767 bfd_release (abfd, i_shdrp);
768 if (new_tdata != NULL)
769 bfd_release (abfd, new_tdata);
770 elf_tdata (abfd) = preserved_tdata;
a17cc40f
HPN		 771 abfd->sections = preserved_sections;
772 abfd->section_count = preserved_section_count;
252b5132
RH		 773 return (NULL);
774}
775\f
776/* ELF .o/exec file writing */
777
778/* Write out the relocs. */
779
b9f66672
JL		 780void
781elf_write_relocs (abfd, sec, data)
252b5132
RH		 782 bfd *abfd;
783 asection *sec;
784 PTR data;
785{
786 boolean *failedp = (boolean *) data;
787 Elf_Internal_Shdr *rela_hdr;
788 Elf_External_Rela *outbound_relocas;
789 Elf_External_Rel *outbound_relocs;
790 unsigned int idx;
bf572ba0 791 int use_rela_p;
252b5132
RH		 792 asymbol *last_sym = 0;
793 int last_sym_idx = 0;
794
795 /* If we have already failed, don't do anything. */
796 if (*failedp)
797 return;
798
799 if ((sec->flags & SEC_RELOC) == 0)
800 return;
801
802 /* The linker backend writes the relocs out itself, and sets the
803 reloc_count field to zero to inhibit writing them here. Also,
804 sometimes the SEC_RELOC flag gets set even when there aren't any
805 relocs. */
806 if (sec->reloc_count == 0)
807 return;
808
809 rela_hdr = &elf_section_data (sec)->rel_hdr;
810
811 rela_hdr->sh_size = rela_hdr->sh_entsize * sec->reloc_count;
812 rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size);
813 if (rela_hdr->contents == NULL)
814 {
815 *failedp = true;
816 return;
817 }
818
bf572ba0
MM		 819 /* Figure out whether the relocations are RELA or REL relocations. */
820 if (rela_hdr->sh_type == SHT_RELA)
821 use_rela_p = true;
822 else if (rela_hdr->sh_type == SHT_REL)
823 use_rela_p = false;
824 else
825 /* Every relocation section should be either an SHT_RELA or an
826 SHT_REL section. */
827 abort ();
828
3e932841 829 /* orelocation has the data, reloc_count has the count... */
252b5132
RH		 830 if (use_rela_p)
831 {
832 outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
833
834 for (idx = 0; idx < sec->reloc_count; idx++)
835 {
836 Elf_Internal_Rela dst_rela;
837 Elf_External_Rela *src_rela;
838 arelent *ptr;
839 asymbol *sym;
840 int n;
841
842 ptr = sec->orelocation[idx];
843 src_rela = outbound_relocas + idx;
844
845 /* The address of an ELF reloc is section relative for an object
846 file, and absolute for an executable file or shared library.
847 The address of a BFD reloc is always section relative. */
848 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
849 dst_rela.r_offset = ptr->address;
850 else
851 dst_rela.r_offset = ptr->address + sec->vma;
852
853 sym = *ptr->sym_ptr_ptr;
854 if (sym == last_sym)
855 n = last_sym_idx;
856 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
857 n = STN_UNDEF;
858 else
859 {
860 last_sym = sym;
861 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
862 if (n < 0)
863 {
864 *failedp = true;
865 return;
866 }
867 last_sym_idx = n;
868 }
869
870 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
871 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
872 && ! _bfd_elf_validate_reloc (abfd, ptr))
873 {
874 *failedp = true;
875 return;
876 }
877
878 dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
879
880 dst_rela.r_addend = ptr->addend;
881 elf_swap_reloca_out (abfd, &dst_rela, src_rela);
882 }
883 }
884 else
885 /* REL relocations */
886 {
887 outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
888
889 for (idx = 0; idx < sec->reloc_count; idx++)
890 {
891 Elf_Internal_Rel dst_rel;
892 Elf_External_Rel *src_rel;
893 arelent *ptr;
894 int n;
895 asymbol *sym;
896
897 ptr = sec->orelocation[idx];
898 sym = *ptr->sym_ptr_ptr;
899 src_rel = outbound_relocs + idx;
900
901 /* The address of an ELF reloc is section relative for an object
902 file, and absolute for an executable file or shared library.
903 The address of a BFD reloc is always section relative. */
904 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
905 dst_rel.r_offset = ptr->address;
906 else
907 dst_rel.r_offset = ptr->address + sec->vma;
908
909 if (sym == last_sym)
910 n = last_sym_idx;
eeaf533e
ILT		 911 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
912 n = STN_UNDEF;
252b5132
RH		 913 else
914 {
915 last_sym = sym;
916 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
917 if (n < 0)
918 {
919 *failedp = true;
920 return;
921 }
922 last_sym_idx = n;
923 }
924
2f66722d
AM		 925 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
926 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
252b5132
RH		 927 && ! _bfd_elf_validate_reloc (abfd, ptr))
928 {
929 *failedp = true;
930 return;
931 }
932
933 dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
934
935 elf_swap_reloc_out (abfd, &dst_rel, src_rel);
936 }
937 }
938}
939
940/* Write out the program headers. */
941
942int
943elf_write_out_phdrs (abfd, phdr, count)
944 bfd *abfd;
945 const Elf_Internal_Phdr *phdr;
dc810e39 946 unsigned int count;
252b5132
RH		 947{
948 while (count--)
949 {
950 Elf_External_Phdr extphdr;
951 elf_swap_phdr_out (abfd, phdr, &extphdr);
dc810e39
AM		 952 if (bfd_bwrite (&extphdr, (bfd_size_type) sizeof (Elf_External_Phdr),
953 abfd) != sizeof (Elf_External_Phdr))
252b5132
RH		 954 return -1;
955 phdr++;
956 }
957 return 0;
958}
959
960/* Write out the section headers and the ELF file header. */
961
962boolean
963elf_write_shdrs_and_ehdr (abfd)
964 bfd *abfd;
965{
966 Elf_External_Ehdr x_ehdr; /* Elf file header, external form */
967 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
968 Elf_External_Shdr *x_shdrp; /* Section header table, external form */
969 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
970 unsigned int count;
dc810e39 971 bfd_size_type amt;
252b5132
RH		 972
973 i_ehdrp = elf_elfheader (abfd);
974 i_shdrp = elf_elfsections (abfd);
975
3e932841 976 /* swap the header before spitting it out... */
252b5132
RH		 977
978#if DEBUG & 1
979 elf_debug_file (i_ehdrp);
980#endif
981 elf_swap_ehdr_out (abfd, i_ehdrp, &x_ehdr);
dc810e39 982 amt = sizeof (x_ehdr);
252b5132 983 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
dc810e39 984 || bfd_bwrite ((PTR) & x_ehdr, amt, abfd) != amt)
252b5132
RH		 985 return false;
986
3e932841 987 /* at this point we've concocted all the ELF sections... */
dc810e39
AM		 988 amt = sizeof (*x_shdrp) * i_ehdrp->e_shnum;
989 x_shdrp = (Elf_External_Shdr *) bfd_alloc (abfd, amt);
252b5132
RH		 990 if (!x_shdrp)
991 return false;
992
993 for (count = 0; count < i_ehdrp->e_shnum; count++)
994 {
995#if DEBUG & 2
996 elf_debug_section (count, i_shdrp[count]);
997#endif
998 elf_swap_shdr_out (abfd, i_shdrp[count], x_shdrp + count);
999 }
dc810e39
AM		 1000 amt = i_ehdrp->e_shnum;
1001 amt *= sizeof (*x_shdrp);
252b5132 1002 if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_shoff, SEEK_SET) != 0
dc810e39 1003 || bfd_bwrite ((PTR) x_shdrp, amt, abfd) != amt)
252b5132
RH		 1004 return false;
1005
3e932841 1006 /* need to dump the string table too... */
252b5132
RH		 1007
1008 return true;
1009}
1010
1011long
1012elf_slurp_symbol_table (abfd, symptrs, dynamic)
1013 bfd *abfd;
1014 asymbol **symptrs; /* Buffer for generated bfd symbols */
1015 boolean dynamic;
1016{
1017 Elf_Internal_Shdr *hdr;
1018 Elf_Internal_Shdr *verhdr;
1019 unsigned long symcount; /* Number of external ELF symbols */
1020 elf_symbol_type *sym; /* Pointer to current bfd symbol */
1021 elf_symbol_type *symbase; /* Buffer for generated bfd symbols */
1022 Elf_Internal_Sym i_sym;
1023 Elf_External_Sym *x_symp = NULL;
1024 Elf_External_Versym *x_versymp = NULL;
dc810e39 1025 bfd_size_type amt;
252b5132
RH		 1026
1027 /* Read each raw ELF symbol, converting from external ELF form to
1028 internal ELF form, and then using the information to create a
1029 canonical bfd symbol table entry.
1030
1031 Note that we allocate the initial bfd canonical symbol buffer
1032 based on a one-to-one mapping of the ELF symbols to canonical
1033 symbols. We actually use all the ELF symbols, so there will be no
1034 space left over at the end. When we have all the symbols, we
3e932841 1035 build the caller's pointer vector. */
252b5132
RH		 1036
1037 if (! dynamic)
1038 {
1039 hdr = &elf_tdata (abfd)->symtab_hdr;
1040 verhdr = NULL;
1041 }
1042 else
1043 {
1044 hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1045 if (elf_dynversym (abfd) == 0)
1046 verhdr = NULL;
1047 else
1048 verhdr = &elf_tdata (abfd)->dynversym_hdr;
1049 if ((elf_tdata (abfd)->dynverdef_section != 0
1050 && elf_tdata (abfd)->verdef == NULL)
1051 || (elf_tdata (abfd)->dynverref_section != 0
1052 && elf_tdata (abfd)->verref == NULL))
1053 {
1054 if (! _bfd_elf_slurp_version_tables (abfd))
1055 return -1;
1056 }
1057 }
1058
dc810e39 1059 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0)
252b5132
RH		 1060 return -1;
1061
1062 symcount = hdr->sh_size / sizeof (Elf_External_Sym);
1063
1064 if (symcount == 0)
1065 sym = symbase = NULL;
1066 else
1067 {
1068 unsigned long i;
1069
dc810e39 1070 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0)
252b5132
RH		 1071 return -1;
1072
dc810e39
AM		 1073 amt = symcount;
1074 amt *= sizeof (elf_symbol_type);
1075 symbase = (elf_symbol_type *) bfd_zalloc (abfd, amt);
252b5132
RH		 1076 if (symbase == (elf_symbol_type *) NULL)
1077 return -1;
1078 sym = symbase;
1079
1080 /* Temporarily allocate room for the raw ELF symbols. */
dc810e39
AM		 1081 amt = symcount;
1082 amt *= sizeof (Elf_External_Sym);
1083 x_symp = (Elf_External_Sym *) bfd_malloc (amt);
252b5132
RH		 1084 if (x_symp == NULL && symcount != 0)
1085 goto error_return;
1086
dc810e39
AM		 1087 if (bfd_bread ((PTR) x_symp,
1088 (bfd_size_type) (symcount * sizeof (Elf_External_Sym)),
1089 abfd)
252b5132
RH		 1090 != symcount * sizeof (Elf_External_Sym))
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
dc810e39 1118 if (bfd_bread ((PTR) x_versymp, (bfd_size_type) 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};
GDB Binutils - Deliverables
This page took 0.157226 seconds and 4 git commands to generate.