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