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