1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
63 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
81 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
82 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
83 #define elf_core_file_matches_executable_p NAME(bfd_elf,core_file_matches_executable_p)
84 #define elf_object_p NAME(bfd_elf,object_p)
85 #define elf_core_file_p NAME(bfd_elf,core_file_p)
86 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
87 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
88 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
89 #define elf_get_symtab NAME(bfd_elf,get_symtab)
90 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
91 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
92 #define elf_print_symbol NAME(bfd_elf,print_symbol)
93 #define elf_get_lineno NAME(bfd_elf,get_lineno)
94 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
95 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
96 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
97 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
98 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
99 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
100 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
101 #define write_relocs NAME(bfd_elf,_write_relocs)
102 #define elf_find_section NAME(bfd_elf,find_section)
105 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
106 #define ELF_R_SYM(X) ELF64_R_SYM(X)
107 #define ELFCLASS ELFCLASS64
111 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
112 #define ELF_R_SYM(X) ELF32_R_SYM(X)
113 #define ELFCLASS ELFCLASS32
117 static int shstrtab_length_fixed
;
119 struct elf_sect_data
{
124 /* Forward declarations of static functions */
126 static struct sec
* section_from_elf_index
PARAMS ((bfd
*, int));
128 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
130 static boolean elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**));
132 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
133 struct symbol_cache_entry
**));
135 static boolean elf_map_symbols
PARAMS ((bfd
*));
136 static boolean swap_out_syms
PARAMS ((bfd
*));
139 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
140 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
143 #define elf_string_from_elf_strtab(abfd,strindex) \
144 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
147 /* Structure swapping routines */
149 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
150 can be handled by explicitly specifying 32 bits or "the long type". */
152 #define put_word bfd_h_put_64
153 #define get_word bfd_h_get_64
156 #define put_word bfd_h_put_32
157 #define get_word bfd_h_get_32
160 /* Translate an ELF symbol in external format into an ELF symbol in internal
164 DEFUN (elf_swap_symbol_in
, (abfd
, src
, dst
),
166 Elf_External_Sym
* src AND
167 Elf_Internal_Sym
* dst
)
169 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
170 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
171 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
172 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
173 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
174 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
177 /* Translate an ELF symbol in internal format into an ELF symbol in external
181 DEFUN (elf_swap_symbol_out
, (abfd
, src
, dst
),
183 Elf_Internal_Sym
* src AND
184 Elf_External_Sym
* dst
)
186 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
187 put_word (abfd
, src
->st_value
, dst
->st_value
);
188 put_word (abfd
, src
->st_size
, dst
->st_size
);
189 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
190 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
191 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
195 /* Translate an ELF file header in external format into an ELF file header in
199 DEFUN (elf_swap_ehdr_in
, (abfd
, src
, dst
),
201 Elf_External_Ehdr
* src AND
202 Elf_Internal_Ehdr
* dst
)
204 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
205 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
206 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
207 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
208 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
209 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
210 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
211 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
212 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
213 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
214 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
215 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
216 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
217 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
220 /* Translate an ELF file header in internal format into an ELF file header in
224 DEFUN (elf_swap_ehdr_out
, (abfd
, src
, dst
),
226 Elf_Internal_Ehdr
* src AND
227 Elf_External_Ehdr
* dst
)
229 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
230 /* note that all elements of dst are *arrays of unsigned char* already... */
231 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
232 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
233 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
234 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
235 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
236 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
237 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
238 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
239 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
240 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
241 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
242 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
243 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
247 /* Translate an ELF section header table entry in external format into an
248 ELF section header table entry in internal format. */
251 DEFUN (elf_swap_shdr_in
, (abfd
, src
, dst
),
253 Elf_External_Shdr
* src AND
254 Elf_Internal_Shdr
* dst
)
256 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
257 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
258 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
259 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
260 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
261 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
262 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
263 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
264 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
265 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
266 /* we haven't done any processing on it yet, so... */
267 dst
->rawdata
= (void *) 0;
270 /* Translate an ELF section header table entry in internal format into an
271 ELF section header table entry in external format. */
274 DEFUN (elf_swap_shdr_out
, (abfd
, src
, dst
),
276 Elf_Internal_Shdr
* src AND
277 Elf_External_Shdr
* dst
)
279 /* note that all elements of dst are *arrays of unsigned char* already... */
280 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
281 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
282 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
283 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
284 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
285 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
286 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
287 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
288 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
289 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
293 /* Translate an ELF program header table entry in external format into an
294 ELF program header table entry in internal format. */
297 DEFUN (elf_swap_phdr_in
, (abfd
, src
, dst
),
299 Elf_External_Phdr
* src AND
300 Elf_Internal_Phdr
* dst
)
302 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
303 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
304 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
305 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
306 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
307 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
308 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
309 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
313 DEFUN (elf_swap_phdr_out
, (abfd
, src
, dst
),
315 Elf_Internal_Phdr
* src AND
316 Elf_External_Phdr
* dst
)
318 /* note that all elements of dst are *arrays of unsigned char* already... */
319 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
320 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
321 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
322 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
323 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
324 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
325 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
326 put_word (abfd
, src
->p_align
, dst
->p_align
);
329 /* Translate an ELF reloc from external format to internal format. */
331 DEFUN (elf_swap_reloc_in
, (abfd
, src
, dst
),
333 Elf_External_Rel
* src AND
334 Elf_Internal_Rel
* dst
)
336 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
337 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
341 DEFUN (elf_swap_reloca_in
, (abfd
, src
, dst
),
343 Elf_External_Rela
* src AND
344 Elf_Internal_Rela
* dst
)
346 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
347 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
348 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
351 /* Translate an ELF reloc from internal format to external format. */
353 DEFUN (elf_swap_reloc_out
, (abfd
, src
, dst
),
355 Elf_Internal_Rel
* src AND
356 Elf_External_Rel
* dst
)
358 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
359 put_word (abfd
, src
->r_info
, dst
->r_info
);
363 DEFUN (elf_swap_reloca_out
, (abfd
, src
, dst
),
365 Elf_Internal_Rela
* src AND
366 Elf_External_Rela
* dst
)
368 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
369 put_word (abfd
, src
->r_info
, dst
->r_info
);
370 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
375 /* String table creation/manipulation routines */
377 static struct strtab
*
378 DEFUN (bfd_new_strtab
, (abfd
),
383 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
386 bfd_set_error (bfd_error_no_memory
);
389 ss
->tab
= malloc (1);
392 bfd_set_error (bfd_error_no_memory
);
403 DEFUN (bfd_add_to_strtab
, (abfd
, ss
, str
),
405 struct strtab
*ss AND
408 /* should search first, but for now: */
409 /* include the trailing NUL */
410 int ln
= strlen (str
) + 1;
412 /* should this be using obstacks? */
413 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
415 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
416 strcpy (ss
->tab
+ ss
->length
, str
);
420 return ss
->length
- ln
;
424 DEFUN (bfd_add_2_to_strtab
, (abfd
, ss
, str
, str2
),
426 struct strtab
*ss AND
430 /* should search first, but for now: */
431 /* include the trailing NUL */
432 int ln
= strlen (str
) + strlen (str2
) + 1;
434 /* should this be using obstacks? */
436 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
438 ss
->tab
= malloc (ln
);
440 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
441 strcpy (ss
->tab
+ ss
->length
, str
);
442 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
446 return ss
->length
- ln
;
450 /* ELF .o/exec file reading */
452 /* Create a new bfd section from an ELF section header. */
455 DEFUN (bfd_section_from_shdr
, (abfd
, shindex
),
457 unsigned int shindex
)
459 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
460 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
464 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
466 switch (hdr
->sh_type
)
470 /* inactive section. Throw it away. */
474 /* Bits that get saved. This one is real. */
477 newsect
= bfd_make_section (abfd
, name
);
480 newsect
->filepos
= hdr
->sh_offset
; /* so we can read back the bits */
481 newsect
->flags
|= SEC_HAS_CONTENTS
;
482 newsect
->vma
= hdr
->sh_addr
;
483 newsect
->_raw_size
= hdr
->sh_size
;
484 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
486 if (hdr
->sh_flags
& SHF_ALLOC
)
488 newsect
->flags
|= SEC_ALLOC
;
489 newsect
->flags
|= SEC_LOAD
;
492 if (!(hdr
->sh_flags
& SHF_WRITE
))
493 newsect
->flags
|= SEC_READONLY
;
495 if (hdr
->sh_flags
& SHF_EXECINSTR
)
496 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
497 else if (newsect
->flags
& SEC_ALLOC
)
498 newsect
->flags
|= SEC_DATA
;
500 /* The debugging sections appear to recognized only by
502 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
503 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
504 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
505 newsect
->flags
|= SEC_DEBUGGING
;
507 hdr
->rawdata
= (void *) newsect
;
510 hdr
->rawdata
= (void *) bfd_get_section_by_name (abfd
, name
);
515 /* Bits that get saved. This one is real. */
518 newsect
= bfd_make_section (abfd
, name
);
521 newsect
->vma
= hdr
->sh_addr
;
522 newsect
->_raw_size
= hdr
->sh_size
;
523 newsect
->filepos
= hdr
->sh_offset
; /* fake */
524 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
525 if (hdr
->sh_flags
& SHF_ALLOC
)
526 newsect
->flags
|= SEC_ALLOC
;
528 if (!(hdr
->sh_flags
& SHF_WRITE
))
529 newsect
->flags
|= SEC_READONLY
;
531 /* FIXME: This section is empty. Does it really make
532 sense to set SEC_CODE for it? */
533 if (hdr
->sh_flags
& SHF_EXECINSTR
)
534 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
536 hdr
->rawdata
= (void *) newsect
;
541 case SHT_SYMTAB
: /* A symbol table */
542 if (elf_onesymtab (abfd
) == shindex
)
545 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
546 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
547 elf_onesymtab (abfd
) = shindex
;
548 elf_tdata(abfd
)->symtab_hdr
= *hdr
;
549 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->symtab_hdr
;
550 abfd
->flags
|= HAS_SYMS
;
553 case SHT_STRTAB
: /* A string table */
556 if (ehdr
->e_shstrndx
== shindex
)
558 elf_tdata(abfd
)->shstrtab_hdr
= *hdr
;
559 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->shstrtab_hdr
;
560 hdr
->rawdata
= (PTR
) &elf_tdata(abfd
)->shstrtab_hdr
;
566 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
568 Elf_Internal_Shdr
*hdr2
= elf_elfsections(abfd
)[i
];
569 if (hdr2
->sh_link
== shindex
)
571 bfd_section_from_shdr (abfd
, i
);
572 if (elf_onesymtab (abfd
) == i
)
574 elf_tdata(abfd
)->strtab_hdr
= *hdr
;
575 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->strtab_hdr
;
578 #if 0 /* Not handling other string tables specially right now. */
579 hdr2
= elf_elfsections(abfd
)[i
]; /* in case it moved */
580 /* We have a strtab for some random other section. */
581 newsect
= (asection
*) hdr2
->rawdata
;
584 hdr
->rawdata
= (PTR
) newsect
;
585 hdr2
= &elf_section_data (newsect
)->str_hdr
;
587 elf_elfsections(abfd
)[shindex
] = hdr2
;
593 newsect
= bfd_make_section (abfd
, name
);
596 newsect
->flags
= SEC_HAS_CONTENTS
;
597 hdr
->rawdata
= (PTR
) newsect
;
598 newsect
->_raw_size
= hdr
->sh_size
;
599 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
600 newsect
->vma
= hdr
->sh_addr
;
601 newsect
->filepos
= hdr
->sh_offset
;
603 if (hdr
->sh_flags
& SHF_ALLOC
)
604 newsect
->flags
|= SEC_ALLOC
|SEC_LOAD
;
605 if (!(hdr
->sh_flags
& SHF_WRITE
))
606 newsect
->flags
|= SEC_READONLY
;
607 if (hdr
->sh_flags
& SHF_EXECINSTR
)
608 newsect
->flags
|= SEC_CODE
;
609 else if (newsect
->flags
& SEC_ALLOC
)
610 newsect
->flags
|= SEC_DATA
;
612 /* Check for debugging string tables. */
613 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
614 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
615 newsect
->flags
|= SEC_DEBUGGING
;
622 /* *These* do a lot of work -- but build no sections!
623 The spec says there can be multiple strtabs, but only one symtab,
624 but there can be lots of REL* sections. */
625 /* FIXME: The above statement is wrong! There are typically at least
626 two symbol tables in a dynamically linked executable, ".dynsym"
627 which is the dynamic linkage symbol table and ".symtab", which is
628 the "traditional" symbol table. -fnf */
631 asection
*target_sect
;
632 Elf_Internal_Shdr
*hdr2
;
633 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
635 /* Don't allow REL relocations on a machine that uses RELA and
637 /* @@ Actually, the generic ABI does suggest that both might be
638 used in one file. But the four ABI Processor Supplements I
639 have access to right now all specify that only one is used on
640 each of those architectures. It's conceivable that, e.g., a
641 bunch of absolute 32-bit relocs might be more compact in REL
642 form even on a RELA machine... */
643 BFD_ASSERT (!(use_rela_p
&& (hdr
->sh_type
== SHT_REL
)));
644 BFD_ASSERT (!(!use_rela_p
&& (hdr
->sh_type
== SHT_RELA
)));
645 BFD_ASSERT (hdr
->sh_entsize
==
647 ? sizeof (Elf_External_Rela
)
648 : sizeof (Elf_External_Rel
)));
650 bfd_section_from_shdr (abfd
, hdr
->sh_info
); /* target */
651 bfd_section_from_shdr (abfd
, hdr
->sh_link
); /* symbol table */
652 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
653 if (target_sect
== NULL
654 || elf_section_data (target_sect
) == NULL
)
657 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
659 elf_elfsections(abfd
)[shindex
] = hdr2
;
660 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
661 target_sect
->flags
|= SEC_RELOC
;
662 target_sect
->relocation
= 0;
663 target_sect
->rel_filepos
= hdr
->sh_offset
;
664 abfd
->flags
|= HAS_RELOC
;
671 case SHT_DYNSYM
: /* could treat this like symtab... */
673 fprintf (stderr
, "Dynamic Linking sections not yet supported.\n");
680 fprintf (stderr
, "Note Sections not yet supported.\n");
687 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
692 /* Check for any processor-specific section types. */
694 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
696 if (bed
->elf_backend_section_from_shdr
)
697 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
706 DEFUN (elf_new_section_hook
, (abfd
, sec
),
710 struct bfd_elf_section_data
*sdata
;
712 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
715 bfd_set_error (bfd_error_no_memory
);
718 sec
->used_by_bfd
= (PTR
) sdata
;
719 memset (sdata
, 0, sizeof (*sdata
));
723 /* Create a new bfd section from an ELF program header.
725 Since program segments have no names, we generate a synthetic name
726 of the form segment<NUM>, where NUM is generally the index in the
727 program header table. For segments that are split (see below) we
728 generate the names segment<NUM>a and segment<NUM>b.
730 Note that some program segments may have a file size that is different than
731 (less than) the memory size. All this means is that at execution the
732 system must allocate the amount of memory specified by the memory size,
733 but only initialize it with the first "file size" bytes read from the
734 file. This would occur for example, with program segments consisting
735 of combined data+bss.
737 To handle the above situation, this routine generates TWO bfd sections
738 for the single program segment. The first has the length specified by
739 the file size of the segment, and the second has the length specified
740 by the difference between the two sizes. In effect, the segment is split
741 into it's initialized and uninitialized parts.
746 DEFUN (bfd_section_from_phdr
, (abfd
, hdr
, index
),
748 Elf_Internal_Phdr
* hdr AND
756 split
= ((hdr
->p_memsz
> 0) &&
757 (hdr
->p_filesz
> 0) &&
758 (hdr
->p_memsz
> hdr
->p_filesz
));
759 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
760 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
763 bfd_set_error (bfd_error_no_memory
);
766 strcpy (name
, namebuf
);
767 newsect
= bfd_make_section (abfd
, name
);
768 newsect
->vma
= hdr
->p_vaddr
;
769 newsect
->_raw_size
= hdr
->p_filesz
;
770 newsect
->filepos
= hdr
->p_offset
;
771 newsect
->flags
|= SEC_HAS_CONTENTS
;
772 if (hdr
->p_type
== PT_LOAD
)
774 newsect
->flags
|= SEC_ALLOC
;
775 newsect
->flags
|= SEC_LOAD
;
776 if (hdr
->p_flags
& PF_X
)
778 /* FIXME: all we known is that it has execute PERMISSION,
780 newsect
->flags
|= SEC_CODE
;
783 if (!(hdr
->p_flags
& PF_W
))
785 newsect
->flags
|= SEC_READONLY
;
790 sprintf (namebuf
, "segment%db", index
);
791 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
794 bfd_set_error (bfd_error_no_memory
);
797 strcpy (name
, namebuf
);
798 newsect
= bfd_make_section (abfd
, name
);
799 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
800 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
801 if (hdr
->p_type
== PT_LOAD
)
803 newsect
->flags
|= SEC_ALLOC
;
804 if (hdr
->p_flags
& PF_X
)
805 newsect
->flags
|= SEC_CODE
;
807 if (!(hdr
->p_flags
& PF_W
))
808 newsect
->flags
|= SEC_READONLY
;
814 /* Begin processing a given object.
816 First we validate the file by reading in the ELF header and checking
819 static INLINE boolean
820 DEFUN (elf_file_p
, (x_ehdrp
), Elf_External_Ehdr
* x_ehdrp
)
822 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
823 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
824 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
825 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
828 /* Check to see if the file associated with ABFD matches the target vector
831 Note that we may be called several times with the same ABFD, but different
832 target vectors, most of which will not match. We have to avoid leaving
833 any side effects in ABFD, or any data it points to (like tdata), if the
834 file does not match the target vector.
836 FIXME: There is memory leak if we are called more than once with the same
837 ABFD, and that bfd already has tdata allocated, since we allocate more tdata
838 and the old tdata is orphaned. Since it's in the bfd obstack, there isn't
839 much we can do about this except possibly rewrite the code. There are
840 also other bfd_allocs that may be the source of memory leaks as well. */
843 DEFUN (elf_object_p
, (abfd
), bfd
* abfd
)
845 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
846 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
847 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
848 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
850 char *shstrtab
; /* Internal copy of section header stringtab */
851 struct elf_backend_data
*ebd
;
852 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
854 /* Read in the ELF header in external format. */
856 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
857 goto got_system_call
;
859 /* Now check to see if we have a valid ELF file, and one that BFD can
860 make use of. The magic number must match, the address size ('class')
861 and byte-swapping must match our XVEC entry, and it must have a
862 section header table (FIXME: See comments re sections at top of this
865 if ((elf_file_p (&x_ehdr
) == false) ||
866 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
867 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
868 goto got_wrong_format_error
;
870 /* Check that file's byte order matches xvec's */
871 switch (x_ehdr
.e_ident
[EI_DATA
])
873 case ELFDATA2MSB
: /* Big-endian */
874 if (!abfd
->xvec
->header_byteorder_big_p
)
875 goto got_wrong_format_error
;
877 case ELFDATA2LSB
: /* Little-endian */
878 if (abfd
->xvec
->header_byteorder_big_p
)
879 goto got_wrong_format_error
;
881 case ELFDATANONE
: /* No data encoding specified */
882 default: /* Unknown data encoding specified */
883 goto got_wrong_format_error
;
886 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
887 the tdata pointer in the bfd. FIXME: memory leak, see above. */
890 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
891 if (elf_tdata (abfd
) == NULL
)
892 goto got_no_memory_error
;
894 /* Now that we know the byte order, swap in the rest of the header */
895 i_ehdrp
= elf_elfheader (abfd
);
896 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
898 elf_debug_file (i_ehdrp
);
901 /* If there is no section header table, we're hosed. */
902 if (i_ehdrp
->e_shoff
== 0)
903 goto got_wrong_format_error
;
905 /* As a simple sanity check, verify that the what BFD thinks is the
906 size of each section header table entry actually matches the size
907 recorded in the file. */
908 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
909 goto got_wrong_format_error
;
911 ebd
= get_elf_backend_data (abfd
);
913 /* Check that the ELF e_machine field matches what this particular
914 BFD format expects. */
915 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
917 bfd_target
**target_ptr
;
919 if (ebd
->elf_machine_code
!= EM_NONE
)
920 goto got_wrong_format_error
;
922 /* This is the generic ELF target. Let it match any ELF target
923 for which we do not have a specific backend. */
924 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
926 struct elf_backend_data
*back
;
928 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
930 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
931 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
933 /* target_ptr is an ELF backend which matches this
934 object file, so reject the generic ELF target. */
935 goto got_wrong_format_error
;
941 /* Set the flags and architecture before calling the backend so that
942 it can override them. */
943 if (i_ehdrp
->e_type
== ET_EXEC
)
944 abfd
->flags
|= EXEC_P
;
945 else if (i_ehdrp
->e_type
== ET_DYN
)
946 abfd
->flags
|= DYNAMIC
;
948 bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0);
950 /* Remember the entry point specified in the ELF file header. */
951 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
953 /* Let the backend double check the format and override global
955 if (ebd
->elf_backend_object_p
)
957 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
958 goto got_wrong_format_error
;
961 /* Allocate space for a copy of the section header table in
962 internal form, seek to the section header table in the file,
963 read it in, and convert it to internal form. */
964 i_shdrp
= (Elf_Internal_Shdr
*)
965 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
);
966 elf_elfsections (abfd
) =
967 (Elf_Internal_Shdr
**) bfd_alloc (abfd
, sizeof (i_shdrp
) * i_ehdrp
->e_shnum
);
968 if (!i_shdrp
|| !elf_elfsections(abfd
))
969 goto got_no_memory_error
;
970 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) == -1)
971 goto got_system_call
;
972 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
974 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
975 goto got_system_call
;
976 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
977 elf_elfsections(abfd
)[shindex
] = i_shdrp
+ shindex
;
979 /* If this is a .dynamic section, mark the object file as being
980 dynamically linked. */
981 if (i_shdrp
[shindex
].sh_type
== SHT_DYNAMIC
)
982 abfd
->flags
|= DYNAMIC
;
984 if (i_ehdrp
->e_shstrndx
)
986 bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
);
990 for (shindex
= i_ehdrp
->e_shnum
- 1; shindex
>= 0; shindex
--)
992 if (!strcmp (elf_string_from_elf_strtab (abfd
,
993 i_shdrp
[shindex
].sh_name
),
996 elf_tdata(abfd
)->strtab_hdr
= i_shdrp
[shindex
];
997 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->strtab_hdr
;
999 else if (!strcmp (elf_string_from_elf_strtab (abfd
,
1000 i_shdrp
[shindex
].sh_name
),
1003 elf_tdata(abfd
)->symtab_hdr
= i_shdrp
[shindex
];
1004 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->symtab_hdr
;
1005 elf_onesymtab (abfd
) = shindex
;
1010 /* Read in the string table containing the names of the sections. We
1011 will need the base pointer to this table later. */
1012 /* We read this inline now, so that we don't have to go through
1013 bfd_section_from_shdr with it (since this particular strtab is
1014 used to find all of the ELF section names.) */
1016 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
1018 goto got_wrong_format_error
;
1020 /* Once all of the section headers have been read and converted, we
1021 can start processing them. Note that the first section header is
1022 a dummy placeholder entry, so we ignore it.
1024 We also watch for the symbol table section and remember the file
1025 offset and section size for both the symbol table section and the
1026 associated string table section. */
1028 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1030 bfd_section_from_shdr (abfd
, shindex
);
1033 return (abfd
->xvec
);
1035 /* If we are going to use goto's to avoid duplicating error setting
1036 and return(NULL) code, then this at least makes it more maintainable. */
1039 bfd_set_error (bfd_error_system_call
);
1041 got_wrong_format_error
:
1042 bfd_set_error (bfd_error_wrong_format
);
1044 got_no_memory_error
:
1045 bfd_set_error (bfd_error_no_memory
);
1048 elf_tdata (abfd
) = preserved_tdata
;
1053 /* ELF .o/exec file writing */
1055 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1056 of the symbol if there is one. */
1057 static INLINE elf_symbol_type
*
1058 DEFUN (elf_symbol_from
, (ignore_abfd
, symbol
),
1059 bfd
* ignore_abfd AND
1062 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1065 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1068 return (elf_symbol_type
*) symbol
;
1071 /* Create ELF output from BFD sections.
1073 Essentially, just create the section header and forget about the program
1077 DEFUN (elf_make_sections
, (abfd
, asect
, obj
),
1079 asection
* asect AND
1082 /* most of what is in bfd_shdr_from_section goes in here... */
1083 /* and all of these sections generate at *least* one ELF section. */
1084 Elf_Internal_Shdr
*this_hdr
;
1085 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1087 this_hdr
->sh_addr
= asect
->vma
;
1088 this_hdr
->sh_size
= asect
->_raw_size
;
1089 /* contents already set by elf_set_section_contents */
1091 if (asect
->flags
& SEC_RELOC
)
1093 /* emit a reloc section, and thus strtab and symtab... */
1094 Elf_Internal_Shdr
*rela_hdr
;
1095 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1097 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1099 /* orelocation has the data, reloc_count has the count... */
1102 rela_hdr
->sh_type
= SHT_RELA
;
1103 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1106 /* REL relocations */
1108 rela_hdr
->sh_type
= SHT_REL
;
1109 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1111 rela_hdr
->sh_flags
= 0;
1112 rela_hdr
->sh_addr
= 0;
1113 rela_hdr
->sh_offset
= 0;
1115 /* FIXME: Systems I've checked use an alignment of 4, but it is
1116 possible that some systems use a different alignment. */
1117 rela_hdr
->sh_addralign
= 4;
1121 if (asect
->flags
& SEC_ALLOC
)
1123 this_hdr
->sh_flags
|= SHF_ALLOC
;
1124 if (asect
->flags
& SEC_LOAD
)
1126 /* @@ Do something with sh_type? */
1131 /* If this section is not part of the program image during
1132 execution, leave the address fields at 0. */
1133 this_hdr
->sh_addr
= 0;
1136 if (!(asect
->flags
& SEC_READONLY
))
1137 this_hdr
->sh_flags
|= SHF_WRITE
;
1139 if (asect
->flags
& SEC_CODE
)
1140 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1144 write_relocs (abfd
, sec
, xxx
)
1149 Elf_Internal_Shdr
*rela_hdr
;
1150 Elf_External_Rela
*outbound_relocas
;
1151 Elf_External_Rel
*outbound_relocs
;
1153 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1154 asymbol
*last_sym
= 0;
1155 int last_sym_idx
= 9999999; /* should always be written before use */
1157 if ((sec
->flags
& SEC_RELOC
) == 0)
1159 /* Flags are sometimes inconsistent. */
1160 if (sec
->reloc_count
== 0)
1163 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1165 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1166 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1167 if (!rela_hdr
->contents
)
1169 bfd_set_error (bfd_error_no_memory
);
1170 abort(); /* FIXME */
1173 /* orelocation has the data, reloc_count has the count... */
1176 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1178 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1180 Elf_Internal_Rela dst_rela
;
1181 Elf_External_Rela
*src_rela
;
1186 ptr
= sec
->orelocation
[idx
];
1187 src_rela
= outbound_relocas
+ idx
;
1188 if (!(abfd
->flags
& EXEC_P
))
1189 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1191 dst_rela
.r_offset
= ptr
->address
;
1193 sym
= *ptr
->sym_ptr_ptr
;
1194 if (sym
== last_sym
)
1199 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1201 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1203 dst_rela
.r_addend
= ptr
->addend
;
1204 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1208 /* REL relocations */
1210 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1212 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1214 Elf_Internal_Rel dst_rel
;
1215 Elf_External_Rel
*src_rel
;
1220 ptr
= sec
->orelocation
[idx
];
1221 sym
= *ptr
->sym_ptr_ptr
;
1222 src_rel
= outbound_relocs
+ idx
;
1223 if (!(abfd
->flags
& EXEC_P
))
1224 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1226 dst_rel
.r_offset
= ptr
->address
;
1228 if (sym
== last_sym
)
1233 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1235 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1237 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1243 fix_up_strtabs (abfd
, asect
, obj
)
1248 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (asect
)->this_hdr
;
1249 int this_idx
= elf_section_data(asect
)->this_idx
;
1251 /* @@ Check flags! */
1252 if (!strncmp (asect
->name
, ".stab", 5)
1253 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
1255 size_t len
= strlen (asect
->name
) + 1;
1256 char *s
= (char *) alloca (len
);
1257 strcpy (s
, asect
->name
);
1259 asect
= bfd_get_section_by_name (abfd
, s
);
1262 elf_section_data(asect
)->this_hdr
.sh_link
= this_idx
;
1263 /* @@ Assuming 32 bits! */
1264 elf_section_data(asect
)->this_hdr
.sh_entsize
= 0xc;
1266 this_hdr
->sh_type
= SHT_STRTAB
;
1271 DEFUN (elf_fake_sections
, (abfd
, asect
, obj
),
1273 asection
* asect AND
1276 /* most of what is in bfd_shdr_from_section goes in here... */
1277 /* and all of these sections generate at *least* one ELF section. */
1279 Elf_Internal_Shdr
*this_hdr
;
1280 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1282 bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
), asect
->name
);
1283 /* We need to log the type *now* so that elf_section_from_bfd_section
1284 can find us... have to set rawdata too. */
1285 this_hdr
->rawdata
= (void *) asect
;
1286 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1287 if ((asect
->flags
& SEC_ALLOC
) && (asect
->flags
& SEC_LOAD
))
1288 this_hdr
->sh_type
= SHT_PROGBITS
;
1289 else if ((asect
->flags
& SEC_ALLOC
) && ((asect
->flags
& SEC_LOAD
) == 0))
1291 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1292 || strcmp (asect
->name
, ".sbss") == 0);
1293 this_hdr
->sh_type
= SHT_NOBITS
;
1295 /* FIXME I am not sure how to detect a .note section from the flags
1296 word of an `asection'. */
1297 else if (!strcmp (asect
->name
, ".note"))
1298 this_hdr
->sh_type
= SHT_NOTE
;
1300 this_hdr
->sh_type
= SHT_PROGBITS
;
1302 this_hdr
->sh_flags
= 0;
1303 this_hdr
->sh_addr
= 0;
1304 this_hdr
->sh_size
= 0;
1305 this_hdr
->sh_entsize
= 0;
1306 this_hdr
->sh_info
= 0;
1307 this_hdr
->sh_link
= 0;
1308 this_hdr
->sh_offset
= 0;
1311 /* Now, check for processor-specific section types. */
1313 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1315 if (bed
->elf_backend_fake_sections
)
1316 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1320 /* Emit a strtab and symtab, and possibly a reloc section. */
1321 Elf_Internal_Shdr
*rela_hdr
;
1323 /* Note that only one symtab is used, so just remember it
1326 if (asect
->flags
& SEC_RELOC
)
1328 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1330 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1332 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1333 use_rela_p
? ".rela" : ".rel",
1335 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1336 rela_hdr
->sh_entsize
= (use_rela_p
1337 ? sizeof (Elf_External_Rela
)
1338 : sizeof (Elf_External_Rel
));
1340 rela_hdr
->sh_flags
= 0;
1341 rela_hdr
->sh_addr
= 0;
1342 rela_hdr
->sh_size
= 0;
1343 rela_hdr
->sh_offset
= 0;
1345 /* FIXME: Systems I've checked use an alignment of 4, but some
1346 systems may use a different alignment. */
1347 rela_hdr
->sh_addralign
= 4;
1352 if (asect
->flags
& SEC_ALLOC
)
1354 this_hdr
->sh_flags
|= SHF_ALLOC
;
1355 if (asect
->flags
& SEC_LOAD
)
1357 /* @@ Do something with sh_type? */
1360 if (!(asect
->flags
& SEC_READONLY
))
1361 this_hdr
->sh_flags
|= SHF_WRITE
;
1362 if (asect
->flags
& SEC_CODE
)
1363 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1366 /* Map symbol from it's internal number to the external number, moving
1367 all local symbols to be at the head of the list. */
1370 sym_is_global (abfd
, sym
)
1374 /* If the backend has a special mapping, use it. */
1375 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1376 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1379 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1381 if (sym
->flags
& BSF_LOCAL
)
1385 if (sym
->section
== 0)
1387 /* Is this valid? */
1392 if (sym
->section
== &bfd_und_section
)
1394 if (bfd_is_com_section (sym
->section
))
1396 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1402 DEFUN (elf_map_symbols
, (abfd
), bfd
* abfd
)
1404 int symcount
= bfd_get_symcount (abfd
);
1405 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1406 asymbol
**sect_syms
;
1408 int num_globals
= 0;
1409 int num_locals2
= 0;
1410 int num_globals2
= 0;
1412 int num_sections
= 0;
1413 Elf_Sym_Extra
*sym_extra
;
1418 fprintf (stderr
, "elf_map_symbols\n");
1422 /* Add local symbols for each section for which there are relocs.
1423 FIXME: How can we tell which sections have relocs at this point?
1424 Will reloc_count always be accurate? Actually, I think most ELF
1425 targets create section symbols for all sections anyhow. */
1426 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1428 if (max_index
< asect
->index
)
1429 max_index
= asect
->index
;
1433 elf_num_section_syms (abfd
) = max_index
;
1434 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1435 elf_section_syms (abfd
) = sect_syms
;
1439 bfd_set_error (bfd_error_no_memory
);
1443 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1445 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1448 bfd_set_error (bfd_error_no_memory
);
1451 sym
->the_bfd
= abfd
;
1452 sym
->name
= asect
->name
;
1453 sym
->value
= asect
->vma
;
1454 sym
->flags
= BSF_SECTION_SYM
;
1455 sym
->section
= asect
;
1456 sect_syms
[asect
->index
] = sym
;
1460 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1461 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1468 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1469 ((symcount
+ num_sections
+ 1)
1470 * sizeof (asymbol
*)));
1472 syms
= (asymbol
**) bfd_alloc (abfd
,
1473 (num_sections
+ 1) * sizeof (asymbol
*));
1476 bfd_set_error (bfd_error_no_memory
);
1480 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1482 if (sect_syms
[asect
->index
])
1483 syms
[symcount
++] = sect_syms
[asect
->index
];
1486 syms
[symcount
] = (asymbol
*) 0;
1487 bfd_set_symtab (abfd
, syms
, symcount
);
1490 elf_sym_extra (abfd
) = sym_extra
1491 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1494 bfd_set_error (bfd_error_no_memory
);
1498 /* Identify and classify all of the symbols. */
1499 for (idx
= 0; idx
< symcount
; idx
++)
1501 if (!sym_is_global (abfd
, syms
[idx
]))
1507 /* Now provide mapping information. Add +1 for skipping over the
1509 for (idx
= 0; idx
< symcount
; idx
++)
1511 syms
[idx
]->udata
= (PTR
) &sym_extra
[idx
];
1512 if (!sym_is_global (abfd
, syms
[idx
]))
1513 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1515 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1518 elf_num_locals (abfd
) = num_locals
;
1519 elf_num_globals (abfd
) = num_globals
;
1523 static boolean
assign_section_numbers ();
1524 static boolean
assign_file_positions_except_relocs ();
1527 DEFUN (elf_compute_section_file_positions
, (abfd
), bfd
* abfd
)
1529 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1531 if (!assign_section_numbers (abfd
))
1534 bfd_map_over_sections (abfd
, elf_make_sections
, 0);
1536 bfd_map_over_sections (abfd
, fix_up_strtabs
, 0); /* .stab/.stabstr &c */
1538 if (swap_out_syms (abfd
) == false)
1541 if (!assign_file_positions_except_relocs (abfd
))
1548 DEFUN (elf_write_phdrs
, (abfd
, i_ehdrp
, i_phdrp
, phdr_cnt
),
1550 Elf_Internal_Ehdr
* i_ehdrp AND
1551 Elf_Internal_Phdr
* i_phdrp AND
1552 Elf32_Half phdr_cnt
)
1554 /* first program header entry goes after the file header */
1555 int outbase
= i_ehdrp
->e_phoff
;
1557 Elf_External_Phdr x_phdr
;
1559 for (i
= 0; i
< phdr_cnt
; i
++)
1561 elf_swap_phdr_out (abfd
, i_phdrp
+ i
, &x_phdr
);
1562 bfd_seek (abfd
, outbase
, SEEK_SET
);
1563 bfd_write ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
);
1564 outbase
+= sizeof (x_phdr
);
1570 static const Elf_Internal_Shdr null_shdr
;
1572 /* Assign all ELF section numbers. The dummy first section is handled here
1573 too. The link/info pointers for the standard section types are filled
1574 in here too, while we're at it. (Link pointers for .stab sections are
1575 not filled in here.) */
1577 assign_section_numbers (abfd
)
1580 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1582 int section_number
= 1;
1584 Elf_Internal_Shdr
**i_shdrp
;
1586 t
->shstrtab_hdr
.sh_size
= elf_shstrtab(abfd
)->length
;
1587 t
->shstrtab_hdr
.contents
= (void *) elf_shstrtab(abfd
)->tab
;
1588 shstrtab_length_fixed
= 1;
1590 t
->shstrtab_section
= section_number
++;
1591 elf_elfheader(abfd
)->e_shstrndx
= t
->shstrtab_section
;
1594 t
->symtab_section
= section_number
++;
1595 t
->strtab_section
= section_number
++;
1596 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1598 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1600 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1601 d
->this_idx
= section_number
++;
1602 if (sec
->flags
& SEC_RELOC
)
1604 d
->rel_idx
= section_number
++;
1605 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1606 d
->rel_hdr
.sh_info
= d
->this_idx
;
1610 /* No handling for per-section string tables currently. */
1612 elf_elfheader(abfd
)->e_shnum
= section_number
;
1614 /* Set up the list of section header pointers, in agreement with the
1616 i_shdrp
= (Elf_Internal_Shdr
**)
1617 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*));
1620 bfd_set_error (bfd_error_no_memory
);
1623 elf_elfsections(abfd
) = i_shdrp
;
1624 for (i
= 0; i
< section_number
; i
++)
1627 i_shdrp
[0] = (Elf_Internal_Shdr
*) &null_shdr
;
1628 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1631 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1632 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1634 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1636 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1637 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1639 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1641 /* Make sure we got everything.... */
1642 for (i
= 0; i
< section_number
; i
++)
1643 if (i_shdrp
[i
] == 0)
1648 static INLINE file_ptr
1649 assign_file_position_for_section (i_shdrp
, offset
)
1650 Elf_Internal_Shdr
*i_shdrp
;
1655 if (i_shdrp
->sh_addralign
!= 0)
1656 align
= i_shdrp
->sh_addralign
;
1659 i_shdrp
->sh_offset
= offset
= BFD_ALIGN (offset
, align
);
1660 if (i_shdrp
->rawdata
!= NULL
)
1661 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1662 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1663 offset
+= i_shdrp
->sh_size
;
1667 static INLINE file_ptr
1668 align_file_position (off
)
1671 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1674 static INLINE file_ptr
1675 assign_file_positions_for_symtab_and_strtabs (abfd
, off
)
1679 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1681 off
= align_file_position (off
);
1682 off
= assign_file_position_for_section (&t
->symtab_hdr
, off
);
1683 off
= assign_file_position_for_section (&t
->shstrtab_hdr
, off
);
1684 off
= assign_file_position_for_section (&t
->strtab_hdr
, off
);
1689 bfd_vma low
, mem_size
;
1693 struct seg_info
*next
;
1697 map_program_segments (abfd
)
1700 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1701 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1702 Elf_Internal_Shdr
*i_shdrp
;
1703 Elf_Internal_Phdr
*phdr
;
1706 file_ptr lowest_offset
= 0;
1707 struct seg_info
*seg
= NULL
;
1709 done
= (char *) alloca (i_ehdrp
->e_shnum
);
1710 memset (done
, 0, i_ehdrp
->e_shnum
);
1711 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1713 i_shdrp
= i_shdrpp
[i
];
1714 /* If it's going to be mapped in, it's been assigned a position. */
1715 if (i_shdrp
->sh_offset
+ 1 == 0)
1717 /* Well, not really, but we won't process it here. */
1721 if (i_shdrp
->sh_offset
< lowest_offset
1722 || lowest_offset
== 0)
1723 lowest_offset
= i_shdrp
->sh_offset
;
1724 /* Only interested in PROGBITS or NOBITS for generating segments. */
1725 switch (i_shdrp
->sh_type
)
1738 bfd_vma lowest_vma
= -1, high
;
1742 struct seg_info
*snew
;
1743 struct seg_info
**s_ptr
;
1745 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1747 i_shdrp
= i_shdrpp
[i
];
1748 if (!done
[i
] && i_shdrp
->sh_addr
< lowest_vma
)
1750 lowest_vma
= i_shdrp
->sh_addr
;
1756 /* So now we know the lowest vma of any unassigned sections; start
1758 snew
= (struct seg_info
*) bfd_alloc (abfd
, sizeof (struct seg_info
));
1761 bfd_set_error (bfd_error_no_memory
);
1765 while (*s_ptr
!= (struct seg_info
*) NULL
)
1766 s_ptr
= &(*s_ptr
)->next
;
1769 snew
->low
= lowest_vma
;
1770 i_shdrp
= i_shdrpp
[low_sec
];
1771 snew
->start_pos
= i_shdrp
->sh_offset
;
1772 snew
->sh_flags
= i_shdrp
->sh_flags
;
1773 done
[low_sec
] = 1, n_left
--;
1774 mem_size
= i_shdrp
->sh_size
;
1775 high
= lowest_vma
+ i_shdrp
->sh_size
;
1777 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1778 file_size
= i_shdrp
->sh_size
;
1780 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1786 i_shdrp
= i_shdrpp
[i
];
1787 /* position of next byte on disk */
1788 f1
= snew
->start_pos
+ file_size
;
1789 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1791 if (i_shdrp
->sh_offset
- f1
!= i_shdrp
->sh_addr
- high
)
1793 if (file_size
!= mem_size
)
1796 else /* sh_type == NOBITS */
1798 /* If the section in question has no contents in the disk
1799 file, we really don't care where it supposedly starts.
1800 But we don't want to bother merging it into this segment
1801 if it doesn't start on this memory page. */
1802 bfd_vma page1
, page2
;
1803 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1805 /* page number in address space of current end of snew */
1806 page1
= (high
- 1 + maxpagesize
- 1) / maxpagesize
;
1807 /* page number in address space of start of this section */
1808 page2
= (i_shdrp
->sh_addr
+ maxpagesize
- 1) / maxpagesize
;
1813 done
[i
] = 1, n_left
--;
1814 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1815 file_size
= i_shdrp
->sh_offset
+ i_shdrp
->sh_size
- snew
->start_pos
;
1816 mem_size
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
- snew
->low
;
1817 high
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
;
1820 snew
->file_size
= file_size
;
1821 snew
->mem_size
= mem_size
;
1823 /* Now do something with the list of segments we've built up. */
1825 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1830 for (s
= seg
; s
; s
= s
->next
)
1834 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1835 sz
= sizeof (Elf_External_Phdr
) * n_segs
;
1836 if (align_file_position (i_ehdrp
->e_ehsize
) + sz
<= lowest_offset
)
1837 i_ehdrp
->e_phoff
= align_file_position (i_ehdrp
->e_ehsize
);
1840 i_ehdrp
->e_phoff
= align_file_position (elf_tdata (abfd
)->next_file_pos
);
1841 elf_tdata (abfd
)->next_file_pos
= i_ehdrp
->e_phoff
+ sz
;
1843 phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
,
1844 n_segs
* sizeof (Elf_Internal_Phdr
));
1847 bfd_set_error (bfd_error_no_memory
);
1848 abort(); /* FIXME */
1850 elf_tdata (abfd
)->phdr
= phdr
;
1853 phdr
->p_type
= PT_LOAD
; /* only type we really support so far */
1854 phdr
->p_offset
= seg
->start_pos
;
1855 phdr
->p_vaddr
= seg
->low
;
1857 phdr
->p_filesz
= seg
->file_size
;
1858 phdr
->p_memsz
= seg
->mem_size
;
1859 phdr
->p_flags
= PF_R
;
1860 phdr
->p_align
= maxpagesize
; /* ? */
1861 if (seg
->sh_flags
& SHF_WRITE
)
1862 /* SysVr4 ELF docs say "data segments normally have read, write,
1863 and execute permissions." */
1864 phdr
->p_flags
|= (PF_W
| PF_X
);
1865 if (seg
->sh_flags
& SHF_EXECINSTR
)
1866 phdr
->p_flags
|= PF_X
;
1870 i_ehdrp
->e_phnum
= n_segs
;
1872 elf_write_phdrs (abfd
, i_ehdrp
, elf_tdata (abfd
)->phdr
, i_ehdrp
->e_phnum
);
1877 assign_file_positions_except_relocs (abfd
)
1880 /* For now, we ignore the possibility of having program segments, which
1881 may require some alignment in the file. That'll require padding, and
1882 some interesting calculations to optimize file space usage.
1884 Also, since the application may change the list of relocations for
1885 a given section, we don't figure them in here. We'll put them at the
1886 end of the file, at positions computed during bfd_close.
1888 The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
1889 or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
1891 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1894 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1895 Elf_Internal_Shdr
*i_shdrp
;
1896 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1897 int exec_p
= (abfd
->flags
& EXEC_P
) != 0;
1898 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1900 /* Everything starts after the ELF file header. */
1901 off
= i_ehdrp
->e_ehsize
;
1905 /* Section headers. */
1906 off
= align_file_position (off
);
1907 i_ehdrp
->e_shoff
= off
;
1908 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1909 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1911 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1913 /* The symtab and strtab sections are placed by
1914 assign_file_positions_for_symtab_and_strtabs. */
1915 if (i
== t
->symtab_section
1916 || i
== t
->strtab_section
1917 || i
== t
->shstrtab_section
)
1920 i_shdrp
= i_shdrpp
[i
];
1921 if (i_shdrp
->sh_type
== SHT_REL
|| i_shdrp
->sh_type
== SHT_RELA
)
1923 i_shdrp
->sh_offset
= -1;
1928 if (maxpagesize
== 0)
1929 maxpagesize
= 1; /* make the arithmetic work */
1930 /* This isn't necessarily going to give the best packing, if the
1931 segments require padding between them, but since that isn't
1932 usually the case, this'll do. */
1933 if ((i_shdrp
->sh_flags
& SHF_ALLOC
) == 0)
1935 i_shdrp
->sh_offset
= -1;
1938 /* Blindly assume that the segments are ordered optimally. With
1939 the default LD script, they will be. */
1940 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1942 /* need big unsigned type */
1944 addtl_off
= i_shdrp
->sh_addr
- off
;
1945 addtl_off
= addtl_off
% maxpagesize
;
1952 off
= assign_file_position_for_section (i_shdrp
, off
);
1955 && i_shdrp
->sh_type
== SHT_NOBITS
1956 && (i
== i_ehdrp
->e_shnum
1957 || i_shdrpp
[i
+ 1]->sh_type
!= SHT_NOBITS
))
1959 /* Skip to the next page to ensure that when the file is
1960 loaded the bss section is loaded with zeroes. I don't
1961 know if this is required on all platforms, but it
1962 shouldn't really hurt. */
1963 off
= BFD_ALIGN (off
, maxpagesize
);
1967 && get_elf_backend_data(abfd
)->maxpagesize
> 1
1968 && i_shdrp
->sh_type
== SHT_PROGBITS
1969 && (i_shdrp
->sh_flags
& SHF_ALLOC
)
1970 && (i_shdrp
->sh_offset
- i_shdrp
->sh_addr
) % get_elf_backend_data (abfd
)->maxpagesize
!= 0)
1975 elf_tdata (abfd
)->next_file_pos
= off
;
1976 if (!map_program_segments (abfd
))
1978 off
= elf_tdata (abfd
)->next_file_pos
;
1980 /* Section headers. */
1981 off
= align_file_position (off
);
1982 i_ehdrp
->e_shoff
= off
;
1983 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1985 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1987 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1989 i_shdrp
= i_shdrpp
[i
];
1990 if (i_shdrp
->sh_offset
+ 1 == 0
1991 && i_shdrp
->sh_type
!= SHT_REL
1992 && i_shdrp
->sh_type
!= SHT_RELA
)
1993 off
= assign_file_position_for_section (i_shdrp
, off
);
1996 elf_tdata (abfd
)->next_file_pos
= off
;
2004 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2005 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2006 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2008 struct strtab
*shstrtab
;
2010 i_ehdrp
= elf_elfheader (abfd
);
2011 i_shdrp
= elf_elfsections (abfd
);
2013 shstrtab
= bfd_new_strtab (abfd
);
2017 elf_shstrtab (abfd
) = shstrtab
;
2019 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2020 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2021 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2022 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2024 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2025 i_ehdrp
->e_ident
[EI_DATA
] =
2026 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2027 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2029 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2030 i_ehdrp
->e_ident
[count
] = 0;
2032 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
2033 switch (bfd_get_arch (abfd
))
2035 case bfd_arch_unknown
:
2036 i_ehdrp
->e_machine
= EM_NONE
;
2038 case bfd_arch_sparc
:
2039 i_ehdrp
->e_machine
= EM_SPARC
;
2040 /* start-sanitize-v9 */
2042 i_ehdrp
->e_machine
= EM_SPARC64
;
2044 /* end-sanitize-v9 */
2047 i_ehdrp
->e_machine
= EM_386
;
2050 i_ehdrp
->e_machine
= EM_68K
;
2053 i_ehdrp
->e_machine
= EM_88K
;
2056 i_ehdrp
->e_machine
= EM_860
;
2058 case bfd_arch_mips
: /* MIPS Rxxxx */
2059 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2062 i_ehdrp
->e_machine
= EM_HPPA
;
2064 case bfd_arch_powerpc
:
2065 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2067 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2069 i_ehdrp
->e_machine
= EM_NONE
;
2071 i_ehdrp
->e_version
= EV_CURRENT
;
2072 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2074 /* no program header, for now. */
2075 i_ehdrp
->e_phoff
= 0;
2076 i_ehdrp
->e_phentsize
= 0;
2077 i_ehdrp
->e_phnum
= 0;
2079 /* each bfd section is section header entry */
2080 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2081 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2083 /* if we're building an executable, we'll need a program header table */
2084 if (abfd
->flags
& EXEC_P
)
2086 /* it all happens later */
2088 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2090 /* elf_build_phdrs() returns a (NULL-terminated) array of
2091 Elf_Internal_Phdrs */
2092 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2093 i_ehdrp
->e_phoff
= outbase
;
2094 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2099 i_ehdrp
->e_phentsize
= 0;
2101 i_ehdrp
->e_phoff
= 0;
2104 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2106 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2108 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2114 swap_out_syms (abfd
)
2117 if (!elf_map_symbols (abfd
))
2120 /* Dump out the symtabs. */
2122 int symcount
= bfd_get_symcount (abfd
);
2123 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2124 struct strtab
*stt
= bfd_new_strtab (abfd
);
2125 Elf_Internal_Shdr
*symtab_hdr
;
2126 Elf_Internal_Shdr
*symstrtab_hdr
;
2127 Elf_External_Sym
*outbound_syms
;
2132 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2133 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2134 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2135 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2136 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2138 /* FIXME: Systems I've checked use 4 byte alignment for .symtab,
2139 but it is possible that there are systems which use a different
2141 symtab_hdr
->sh_addralign
= 4;
2143 /* see assert in elf_fake_sections that supports this: */
2144 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2145 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2147 outbound_syms
= (Elf_External_Sym
*)
2148 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2151 bfd_set_error (bfd_error_no_memory
);
2154 /* now generate the data (for "contents") */
2156 /* Fill in zeroth symbol and swap it out. */
2157 Elf_Internal_Sym sym
;
2163 sym
.st_shndx
= SHN_UNDEF
;
2164 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2166 for (idx
= 0; idx
< symcount
; idx
++)
2168 Elf_Internal_Sym sym
;
2169 bfd_vma value
= syms
[idx
]->value
;
2171 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2172 /* Section symbols have no names. */
2175 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2177 if (bfd_is_com_section (syms
[idx
]->section
))
2179 /* ELF common symbols put the alignment into the `value' field,
2180 and the size into the `size' field. This is backwards from
2181 how BFD handles it, so reverse it here. */
2182 sym
.st_size
= value
;
2183 /* Should retrieve this from somewhere... */
2185 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2186 syms
[idx
]->section
);
2190 asection
*sec
= syms
[idx
]->section
;
2191 elf_symbol_type
*type_ptr
;
2194 if (sec
->output_section
)
2196 value
+= sec
->output_offset
;
2197 sec
= sec
->output_section
;
2200 sym
.st_value
= value
;
2201 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2202 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2203 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2207 /* Writing this would be a hell of a lot easier if we had
2208 some decent documentation on bfd, and knew what to expect
2209 of the library, and what to demand of applications. For
2210 example, it appears that `objcopy' might not set the
2211 section of a symbol to be a section that is actually in
2213 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2215 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2216 assert (shndx
!= -1);
2220 if (bfd_is_com_section (syms
[idx
]->section
))
2221 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2222 else if (syms
[idx
]->section
== &bfd_und_section
)
2223 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2224 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2225 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2226 else if (syms
[idx
]->flags
& BSF_FILE
)
2227 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2230 int bind
= STB_LOCAL
;
2231 int type
= STT_OBJECT
;
2232 unsigned int flags
= syms
[idx
]->flags
;
2234 if (flags
& BSF_LOCAL
)
2236 else if (flags
& BSF_WEAK
)
2238 else if (flags
& BSF_GLOBAL
)
2241 if (flags
& BSF_FUNCTION
)
2244 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2248 elf_swap_symbol_out (abfd
, &sym
,
2250 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2253 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2254 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2255 symstrtab_hdr
->sh_size
= stt
->length
;
2256 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2258 symstrtab_hdr
->sh_flags
= 0;
2259 symstrtab_hdr
->sh_addr
= 0;
2260 symstrtab_hdr
->sh_entsize
= 0;
2261 symstrtab_hdr
->sh_link
= 0;
2262 symstrtab_hdr
->sh_info
= 0;
2263 symstrtab_hdr
->sh_addralign
= 1;
2264 symstrtab_hdr
->size
= 0;
2267 /* put the strtab out too... */
2269 Elf_Internal_Shdr
*this_hdr
;
2271 this_hdr
= &elf_tdata(abfd
)->shstrtab_hdr
;
2272 this_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
2273 this_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
2274 this_hdr
->sh_type
= SHT_STRTAB
;
2275 this_hdr
->sh_flags
= 0;
2276 this_hdr
->sh_addr
= 0;
2277 this_hdr
->sh_entsize
= 0;
2278 this_hdr
->sh_addralign
= 1;
2285 write_shdrs_and_ehdr (abfd
)
2288 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2289 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2290 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2291 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2293 struct strtab
*shstrtab
;
2295 i_ehdrp
= elf_elfheader (abfd
);
2296 i_shdrp
= elf_elfsections (abfd
);
2297 shstrtab
= elf_shstrtab (abfd
);
2299 /* swap the header before spitting it out... */
2302 elf_debug_file (i_ehdrp
);
2304 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2305 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
2306 bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
);
2308 /* at this point we've concocted all the ELF sections... */
2309 x_shdrp
= (Elf_External_Shdr
*)
2310 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2313 bfd_set_error (bfd_error_no_memory
);
2317 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2320 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2323 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2325 bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
);
2326 bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
);
2327 /* need to dump the string table too... */
2333 assign_file_positions_for_relocs (abfd
)
2336 file_ptr off
= elf_tdata(abfd
)->next_file_pos
;
2338 Elf_Internal_Shdr
**shdrpp
= elf_elfsections (abfd
);
2339 Elf_Internal_Shdr
*shdrp
;
2340 for (i
= 1; i
< elf_elfheader(abfd
)->e_shnum
; i
++)
2343 if (shdrp
->sh_type
!= SHT_REL
&& shdrp
->sh_type
!= SHT_RELA
)
2345 off
= align_file_position (off
);
2346 off
= assign_file_position_for_section (shdrp
, off
);
2348 elf_tdata(abfd
)->next_file_pos
= off
;
2352 DEFUN (NAME(bfd_elf
,write_object_contents
), (abfd
), bfd
* abfd
)
2354 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2355 Elf_Internal_Ehdr
*i_ehdrp
;
2356 Elf_Internal_Shdr
**i_shdrp
;
2359 /* We don't know how to write dynamic objects. Specifically, we
2360 don't know how to construct the program header. */
2361 if ((abfd
->flags
& DYNAMIC
) != 0)
2363 fprintf (stderr
, "Writing ELF dynamic objects is not supported\n");
2364 bfd_set_error (bfd_error_wrong_format
);
2368 if (abfd
->output_has_begun
== false)
2370 if (prep_headers (abfd
) == false)
2372 if (elf_compute_section_file_positions (abfd
) == false)
2374 abfd
->output_has_begun
= true;
2377 i_shdrp
= elf_elfsections (abfd
);
2378 i_ehdrp
= elf_elfheader (abfd
);
2380 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2381 assign_file_positions_for_relocs (abfd
);
2383 /* After writing the headers, we need to write the sections too... */
2384 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2386 if (bed
->elf_backend_section_processing
)
2387 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2388 if (i_shdrp
[count
]->contents
)
2390 bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
);
2391 bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
, 1,
2396 if (bed
->elf_backend_final_write_processing
)
2397 (*bed
->elf_backend_final_write_processing
) (abfd
);
2399 return write_shdrs_and_ehdr (abfd
);
2402 /* Given an index of a section, retrieve a pointer to it. Note
2403 that for our purposes, sections are indexed by {1, 2, ...} with
2404 0 being an illegal index. */
2406 /* In the original, each ELF section went into exactly one BFD
2407 section. This doesn't really make sense, so we need a real mapping.
2408 The mapping has to hide in the Elf_Internal_Shdr since asection
2409 doesn't have anything like a tdata field... */
2412 DEFUN (section_from_elf_index
, (abfd
, index
),
2416 /* @@ Is bfd_com_section really correct in all the places it could
2417 be returned from this routine? */
2419 if (index
== SHN_ABS
)
2420 return &bfd_com_section
; /* not abs? */
2421 if (index
== SHN_COMMON
)
2422 return &bfd_com_section
;
2424 if (index
> elf_elfheader (abfd
)->e_shnum
)
2428 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2430 switch (hdr
->sh_type
)
2432 /* ELF sections that map to BFD sections */
2436 bfd_section_from_shdr (abfd
, index
);
2437 return (struct sec
*) hdr
->rawdata
;
2440 return (struct sec
*) &bfd_abs_section
;
2445 /* given a section, search the header to find them... */
2447 DEFUN (elf_section_from_bfd_section
, (abfd
, asect
),
2451 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2453 Elf_Internal_Shdr
*hdr
;
2454 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2456 if (asect
== &bfd_abs_section
)
2458 if (asect
== &bfd_com_section
)
2460 if (asect
== &bfd_und_section
)
2463 for (index
= 0; index
< maxindex
; index
++)
2465 hdr
= i_shdrp
[index
];
2466 switch (hdr
->sh_type
)
2468 /* ELF sections that map to BFD sections */
2474 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2480 /* fix_up_strtabs will generate STRTAB sections with names
2482 if (!strncmp (asect
->name
, ".stab", 5)
2483 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
2487 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2495 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2497 if (bed
->elf_backend_section_from_bfd_section
)
2502 if ((*bed
->elf_backend_section_from_bfd_section
)
2503 (abfd
, hdr
, asect
, &retval
))
2513 /* given a symbol, return the bfd index for that symbol. */
2515 DEFUN (elf_symbol_from_bfd_symbol
, (abfd
, asym_ptr_ptr
),
2517 struct symbol_cache_entry
**asym_ptr_ptr
)
2519 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2521 flagword flags
= asym_ptr
->flags
;
2523 /* When gas creates relocations against local labels, it creates its
2524 own symbol for the section, but does put the symbol into the
2525 symbol chain, so udata is 0. When the linker is generating
2526 relocatable output, this section symbol may be for one of the
2527 input sections rather than the output section. */
2528 if (asym_ptr
->udata
== (PTR
) 0
2529 && (flags
& BSF_SECTION_SYM
)
2530 && asym_ptr
->section
)
2534 if (asym_ptr
->section
->output_section
!= NULL
)
2535 indx
= asym_ptr
->section
->output_section
->index
;
2537 indx
= asym_ptr
->section
->index
;
2538 if (elf_section_syms (abfd
)[indx
])
2539 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2542 if (asym_ptr
->udata
)
2543 idx
= ((Elf_Sym_Extra
*)asym_ptr
->udata
)->elf_sym_num
;
2553 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2554 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2563 DEFUN (elf_slurp_symbol_table
, (abfd
, symptrs
),
2565 asymbol
** symptrs
) /* Buffer for generated bfd symbols */
2567 Elf_Internal_Shdr
*hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2568 long symcount
; /* Number of external ELF symbols */
2569 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2570 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2571 Elf_Internal_Sym i_sym
;
2572 Elf_External_Sym
*x_symp
;
2574 /* this is only valid because there is only one symtab... */
2575 /* FIXME: This is incorrect, there may also be a dynamic symbol
2576 table which is a subset of the full symbol table. We either need
2577 to be prepared to read both (and merge them) or ensure that we
2578 only read the full symbol table. Currently we only get called to
2579 read the full symbol table. -fnf */
2581 /* Read each raw ELF symbol, converting from external ELF form to
2582 internal ELF form, and then using the information to create a
2583 canonical bfd symbol table entry.
2585 Note that we allocate the initial bfd canonical symbol buffer
2586 based on a one-to-one mapping of the ELF symbols to canonical
2587 symbols. We actually use all the ELF symbols, so there will be no
2588 space left over at the end. When we have all the symbols, we
2589 build the caller's pointer vector. */
2591 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2593 bfd_set_error (bfd_error_system_call
);
2597 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2600 sym
= symbase
= NULL
;
2605 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2607 bfd_set_error (bfd_error_system_call
);
2611 symbase
= ((elf_symbol_type
*)
2612 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2613 if (symbase
== (elf_symbol_type
*) NULL
)
2615 bfd_set_error (bfd_error_no_memory
);
2620 /* Temporarily allocate room for the raw ELF symbols. */
2621 x_symp
= ((Elf_External_Sym
*)
2622 alloca (symcount
* sizeof (Elf_External_Sym
)));
2624 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2625 != symcount
* sizeof (Elf_External_Sym
))
2627 bfd_set_error (bfd_error_system_call
);
2630 /* Skip first symbol, which is a null dummy. */
2631 for (i
= 1; i
< symcount
; i
++)
2633 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2634 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2635 #ifdef ELF_KEEP_EXTSYM
2636 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2638 sym
->symbol
.the_bfd
= abfd
;
2640 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2643 sym
->symbol
.value
= i_sym
.st_value
;
2645 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
2647 sym
->symbol
.section
= section_from_elf_index (abfd
,
2650 else if (i_sym
.st_shndx
== SHN_ABS
)
2652 sym
->symbol
.section
= &bfd_abs_section
;
2654 else if (i_sym
.st_shndx
== SHN_COMMON
)
2656 sym
->symbol
.section
= &bfd_com_section
;
2657 /* Elf puts the alignment into the `value' field, and
2658 the size into the `size' field. BFD wants to see the
2659 size in the value field, and doesn't care (at the
2660 moment) about the alignment. */
2661 sym
->symbol
.value
= i_sym
.st_size
;
2663 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2665 sym
->symbol
.section
= &bfd_und_section
;
2668 sym
->symbol
.section
= &bfd_abs_section
;
2670 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2672 switch (ELF_ST_BIND (i_sym
.st_info
))
2675 sym
->symbol
.flags
|= BSF_LOCAL
;
2678 sym
->symbol
.flags
|= BSF_GLOBAL
;
2681 sym
->symbol
.flags
|= BSF_WEAK
;
2685 switch (ELF_ST_TYPE (i_sym
.st_info
))
2688 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2691 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2694 sym
->symbol
.flags
|= BSF_FUNCTION
;
2698 /* Do some backend-specific processing on this symbol. */
2700 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2701 if (ebd
->elf_backend_symbol_processing
)
2702 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2709 /* Do some backend-specific processing on this symbol table. */
2711 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2712 if (ebd
->elf_backend_symbol_table_processing
)
2713 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2716 /* We rely on the zalloc to clear out the final symbol entry. */
2718 bfd_get_symcount (abfd
) = symcount
= sym
- symbase
;
2720 /* Fill in the user's symbol pointer vector if needed. */
2724 while (symcount
-- > 0)
2726 *symptrs
++ = &sym
->symbol
;
2729 *symptrs
= 0; /* Final null pointer */
2735 /* Return the number of bytes required to hold the symtab vector.
2737 Note that we base it on the count plus 1, since we will null terminate
2738 the vector allocated based on this size. However, the ELF symbol table
2739 always has a dummy entry as symbol #0, so it ends up even. */
2742 DEFUN (elf_get_symtab_upper_bound
, (abfd
), bfd
* abfd
)
2744 unsigned int symcount
;
2745 unsigned int symtab_size
= 0;
2747 Elf_Internal_Shdr
*hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2748 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2749 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
));
2755 This function return the number of bytes required to store the
2756 relocation information associated with section <<sect>>
2757 attached to bfd <<abfd>>
2761 elf_get_reloc_upper_bound (abfd
, asect
)
2765 if (asect
->flags
& SEC_RELOC
)
2767 /* either rel or rela */
2768 return elf_section_data(asect
)->rel_hdr
.sh_size
;
2775 DEFUN (elf_slurp_reloca_table
, (abfd
, asect
, symbols
),
2780 Elf_External_Rela
*native_relocs
;
2781 arelent
*reloc_cache
;
2786 if (asect
->relocation
)
2788 if (asect
->reloc_count
== 0)
2790 if (asect
->flags
& SEC_CONSTRUCTOR
)
2793 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2794 native_relocs
= (Elf_External_Rela
*)
2795 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2799 bfd_set_error (bfd_error_no_memory
);
2802 bfd_read ((PTR
) native_relocs
,
2803 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
);
2805 reloc_cache
= (arelent
*)
2806 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2810 bfd_set_error (bfd_error_no_memory
);
2814 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2816 Elf_Internal_Rela dst
;
2817 Elf_External_Rela
*src
;
2819 cache_ptr
= reloc_cache
+ idx
;
2820 src
= native_relocs
+ idx
;
2821 elf_swap_reloca_in (abfd
, src
, &dst
);
2823 #ifdef RELOC_PROCESSING
2824 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2826 if (asect
->flags
& SEC_RELOC
)
2828 /* relocatable, so the offset is off of the section */
2829 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2833 /* non-relocatable, so the offset a virtual address */
2834 cache_ptr
->address
= dst
.r_offset
;
2837 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2838 of zero points to the dummy symbol, which was not read into
2839 the symbol table SYMBOLS. */
2840 if (ELF_R_SYM (dst
.r_info
) == 0)
2841 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2846 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2848 /* Translate any ELF section symbol into a BFD section
2850 s
= *(cache_ptr
->sym_ptr_ptr
);
2851 if (s
->flags
& BSF_SECTION_SYM
)
2853 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2854 s
= *cache_ptr
->sym_ptr_ptr
;
2855 if (s
->name
== 0 || s
->name
[0] == 0)
2859 cache_ptr
->addend
= dst
.r_addend
;
2861 /* Fill in the cache_ptr->howto field from dst.r_type */
2863 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2864 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2869 asect
->relocation
= reloc_cache
;
2875 elf_debug_section (str
, num
, hdr
)
2878 Elf_Internal_Shdr
*hdr
;
2880 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
2882 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
2883 (long) hdr
->sh_name
,
2884 (long) hdr
->sh_type
,
2885 (long) hdr
->sh_flags
);
2887 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
2888 (long) hdr
->sh_addr
,
2889 (long) hdr
->sh_offset
,
2890 (long) hdr
->sh_size
);
2892 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
2893 (long) hdr
->sh_link
,
2894 (long) hdr
->sh_info
,
2895 (long) hdr
->sh_addralign
);
2896 fprintf (stderr
, "sh_entsize = %ld\n",
2897 (long) hdr
->sh_entsize
);
2898 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
2899 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
2900 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
2905 elf_debug_file (ehdrp
)
2906 Elf_Internal_Ehdr
*ehdrp
;
2908 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
2909 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
2910 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
2911 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
2912 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
2913 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
2914 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
2919 DEFUN (elf_slurp_reloc_table
, (abfd
, asect
, symbols
),
2924 Elf_External_Rel
*native_relocs
;
2925 arelent
*reloc_cache
;
2927 Elf_Internal_Shdr
*data_hdr
;
2928 ElfNAME (Off
) data_off
;
2929 ElfNAME (Word
) data_max
;
2930 char buf
[4]; /* FIXME -- might be elf64 */
2934 if (asect
->relocation
)
2936 if (asect
->reloc_count
== 0)
2938 if (asect
->flags
& SEC_CONSTRUCTOR
)
2941 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2942 native_relocs
= (Elf_External_Rel
*)
2943 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
2946 bfd_set_error (bfd_error_no_memory
);
2949 bfd_read ((PTR
) native_relocs
,
2950 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
);
2952 reloc_cache
= (arelent
*)
2953 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2957 bfd_set_error (bfd_error_no_memory
);
2961 /* Get the offset of the start of the segment we are relocating to read in
2962 the implicit addend. */
2963 data_hdr
= &elf_section_data(asect
)->this_hdr
;
2964 data_off
= data_hdr
->sh_offset
;
2965 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
2968 elf_debug_section ("data section", -1, data_hdr
);
2971 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2973 #ifdef RELOC_PROCESSING
2974 Elf_Internal_Rel dst
;
2975 Elf_External_Rel
*src
;
2977 cache_ptr
= reloc_cache
+ idx
;
2978 src
= native_relocs
+ idx
;
2979 elf_swap_reloc_in (abfd
, src
, &dst
);
2981 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2983 Elf_Internal_Rel dst
;
2984 Elf_External_Rel
*src
;
2986 cache_ptr
= reloc_cache
+ idx
;
2987 src
= native_relocs
+ idx
;
2989 elf_swap_reloc_in (abfd
, src
, &dst
);
2991 if (asect
->flags
& SEC_RELOC
)
2993 /* relocatable, so the offset is off of the section */
2994 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2998 /* non-relocatable, so the offset a virtual address */
2999 cache_ptr
->address
= dst
.r_offset
;
3002 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
3003 of zero points to the dummy symbol, which was not read into
3004 the symbol table SYMBOLS. */
3005 if (ELF_R_SYM (dst
.r_info
) == 0)
3006 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3011 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
3013 /* Translate any ELF section symbol into a BFD section
3015 s
= *(cache_ptr
->sym_ptr_ptr
);
3016 if (s
->flags
& BSF_SECTION_SYM
)
3018 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3019 s
= *cache_ptr
->sym_ptr_ptr
;
3020 if (s
->name
== 0 || s
->name
[0] == 0)
3024 BFD_ASSERT (dst
.r_offset
<= data_max
);
3025 cache_ptr
->addend
= 0;
3027 /* Fill in the cache_ptr->howto field from dst.r_type */
3029 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
3030 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
3035 asect
->relocation
= reloc_cache
;
3040 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3046 arelent
*tblptr
= section
->relocation
;
3047 unsigned int count
= 0;
3048 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
3050 /* snarfed from coffcode.h */
3052 elf_slurp_reloca_table (abfd
, section
, symbols
);
3054 elf_slurp_reloc_table (abfd
, section
, symbols
);
3056 tblptr
= section
->relocation
;
3060 for (; count
++ < section
->reloc_count
;)
3061 *relptr
++ = tblptr
++;
3064 return section
->reloc_count
;
3068 DEFUN (elf_get_symtab
, (abfd
, alocation
),
3070 asymbol
** alocation
)
3073 if (!elf_slurp_symbol_table (abfd
, alocation
))
3076 return bfd_get_symcount (abfd
);
3080 DEFUN (elf_make_empty_symbol
, (abfd
),
3083 elf_symbol_type
*newsym
;
3085 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3088 bfd_set_error (bfd_error_no_memory
);
3093 newsym
->symbol
.the_bfd
= abfd
;
3094 return &newsym
->symbol
;
3099 DEFUN (elf_get_symbol_info
, (ignore_abfd
, symbol
, ret
),
3100 bfd
* ignore_abfd AND
3101 asymbol
* symbol AND
3104 bfd_symbol_info (symbol
, ret
);
3108 DEFUN (elf_print_symbol
, (ignore_abfd
, filep
, symbol
, how
),
3109 bfd
* ignore_abfd AND
3111 asymbol
* symbol AND
3112 bfd_print_symbol_type how
)
3114 FILE *file
= (FILE *) filep
;
3117 case bfd_print_symbol_name
:
3118 fprintf (file
, "%s", symbol
->name
);
3120 case bfd_print_symbol_more
:
3121 fprintf (file
, "elf ");
3122 fprintf_vma (file
, symbol
->value
);
3123 fprintf (file
, " %lx", (long) symbol
->flags
);
3125 case bfd_print_symbol_all
:
3127 CONST
char *section_name
;
3128 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3129 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3130 fprintf (file
, " %s\t%s",
3140 DEFUN (elf_get_lineno
, (ignore_abfd
, symbol
),
3141 bfd
* ignore_abfd AND
3144 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3151 DEFUN (elf_set_arch_mach
, (abfd
, arch
, machine
),
3153 enum bfd_architecture arch AND
3154 unsigned long machine
)
3156 /* Allow any architecture to be supported by the elf backend */
3159 case bfd_arch_unknown
: /* EM_NONE */
3160 case bfd_arch_sparc
: /* EM_SPARC */
3161 case bfd_arch_i386
: /* EM_386 */
3162 case bfd_arch_m68k
: /* EM_68K */
3163 case bfd_arch_m88k
: /* EM_88K */
3164 case bfd_arch_i860
: /* EM_860 */
3165 case bfd_arch_mips
: /* EM_MIPS (MIPS R3000) */
3166 case bfd_arch_hppa
: /* EM_HPPA (HP PA_RISC) */
3167 case bfd_arch_powerpc
: /* EM_CYGNUS_POWERPC */
3168 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3175 DEFUN (elf_find_nearest_line
, (abfd
,
3183 asection
* section AND
3184 asymbol
** symbols AND
3186 CONST
char **filename_ptr AND
3187 CONST
char **functionname_ptr AND
3188 unsigned int *line_ptr
)
3194 DEFUN (elf_sizeof_headers
, (abfd
, reloc
),
3198 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
3205 DEFUN (elf_set_section_contents
, (abfd
, section
, location
, offset
, count
),
3210 bfd_size_type count
)
3212 Elf_Internal_Shdr
*hdr
;
3214 if (abfd
->output_has_begun
== false) /* set by bfd.c handler? */
3216 /* do setup calculations (FIXME) */
3217 if (prep_headers (abfd
) == false)
3219 if (elf_compute_section_file_positions (abfd
) == false)
3221 abfd
->output_has_begun
= true;
3224 hdr
= &elf_section_data(section
)->this_hdr
;
3226 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3228 if (bfd_write (location
, 1, count
, abfd
) != count
)
3235 DEFUN (elf_no_info_to_howto
, (abfd
, cache_ptr
, dst
),
3237 arelent
* cache_ptr AND
3238 Elf_Internal_Rela
* dst
)
3240 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3246 DEFUN (elf_no_info_to_howto_rel
, (abfd
, cache_ptr
, dst
),
3248 arelent
* cache_ptr AND
3249 Elf_Internal_Rel
* dst
)
3251 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3257 /* Core file support */
3259 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3260 #include <sys/procfs.h>
3262 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
3263 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
3264 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
3270 DEFUN (bfd_prstatus
, (abfd
, descdata
, descsz
, filepos
),
3277 prstatus_t
*status
= (prstatus_t
*) 0;
3279 if (descsz
== sizeof (prstatus_t
))
3281 newsect
= bfd_make_section (abfd
, ".reg");
3282 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3283 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3284 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3285 newsect
->alignment_power
= 2;
3286 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3288 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3293 /* Stash a copy of the prpsinfo structure away for future use. */
3296 DEFUN (bfd_prpsinfo
, (abfd
, descdata
, descsz
, filepos
),
3304 if (descsz
== sizeof (prpsinfo_t
))
3306 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3308 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3314 DEFUN (bfd_fpregset
, (abfd
, descdata
, descsz
, filepos
),
3322 newsect
= bfd_make_section (abfd
, ".reg2");
3323 newsect
->_raw_size
= descsz
;
3324 newsect
->filepos
= filepos
;
3325 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3326 newsect
->alignment_power
= 2;
3329 #endif /* HAVE_PROCFS */
3331 /* Return a pointer to the args (including the command name) that were
3332 seen by the program that generated the core dump. Note that for
3333 some reason, a spurious space is tacked onto the end of the args
3334 in some (at least one anyway) implementations, so strip it off if
3338 DEFUN (elf_core_file_failing_command
, (abfd
),
3342 if (core_prpsinfo (abfd
))
3344 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3345 char *scan
= p
->pr_psargs
;
3350 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3354 return p
->pr_psargs
;
3360 /* Return the number of the signal that caused the core dump. Presumably,
3361 since we have a core file, we got a signal of some kind, so don't bother
3362 checking the other process status fields, just return the signal number.
3366 DEFUN (elf_core_file_failing_signal
, (abfd
),
3370 if (core_prstatus (abfd
))
3372 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3378 /* Check to see if the core file could reasonably be expected to have
3379 come for the current executable file. Note that by default we return
3380 true unless we find something that indicates that there might be a
3385 DEFUN (elf_core_file_matches_executable_p
, (core_bfd
, exec_bfd
),
3394 /* First, xvecs must match since both are ELF files for the same target. */
3396 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3398 bfd_set_error (bfd_error_system_call
);
3404 /* If no prpsinfo, just return true. Otherwise, grab the last component
3405 of the exec'd pathname from the prpsinfo. */
3407 if (core_prpsinfo (core_bfd
))
3409 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3416 /* Find the last component of the executable pathname. */
3418 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3424 execname
= (char *) exec_bfd
->filename
;
3427 /* See if they match */
3429 return strcmp (execname
, corename
) ? false : true;
3435 #endif /* HAVE_PROCFS */
3438 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3439 the information that would normally be available from the /proc interface
3440 for the process, at the time the process dumped core. Currently this
3441 includes copies of the prstatus, prpsinfo, and fpregset structures.
3443 Since these structures are potentially machine dependent in size and
3444 ordering, bfd provides two levels of support for them. The first level,
3445 available on all machines since it does not require that the host
3446 have /proc support or the relevant include files, is to create a bfd
3447 section for each of the prstatus, prpsinfo, and fpregset structures,
3448 without any interpretation of their contents. With just this support,
3449 the bfd client will have to interpret the structures itself. Even with
3450 /proc support, it might want these full structures for it's own reasons.
3452 In the second level of support, where HAVE_PROCFS is defined, bfd will
3453 pick apart the structures to gather some additional information that
3454 clients may want, such as the general register set, the name of the
3455 exec'ed file and its arguments, the signal (if any) that caused the
3461 DEFUN (elf_corefile_note
, (abfd
, hdr
),
3463 Elf_Internal_Phdr
* hdr
)
3465 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3466 Elf_Internal_Note i_note
; /* Elf note, internal form */
3467 char *buf
= NULL
; /* Entire note segment contents */
3468 char *namedata
; /* Name portion of the note */
3469 char *descdata
; /* Descriptor portion of the note */
3470 char *sectname
; /* Name to use for new section */
3471 long filepos
; /* File offset to descriptor data */
3474 if (hdr
->p_filesz
> 0
3475 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3476 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3477 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3479 x_note_p
= (Elf_External_Note
*) buf
;
3480 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3482 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3483 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3484 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3485 namedata
= x_note_p
->name
;
3486 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3487 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3488 switch (i_note
.type
)
3491 /* process descdata as prstatus info */
3492 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
3493 sectname
= ".prstatus";
3496 /* process descdata as fpregset info */
3497 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
3498 sectname
= ".fpregset";
3501 /* process descdata as prpsinfo */
3502 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
3503 sectname
= ".prpsinfo";
3506 /* Unknown descriptor, just ignore it. */
3510 if (sectname
!= NULL
)
3512 newsect
= bfd_make_section (abfd
, sectname
);
3513 newsect
->_raw_size
= i_note
.descsz
;
3514 newsect
->filepos
= filepos
;
3515 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3516 newsect
->alignment_power
= 2;
3518 x_note_p
= (Elf_External_Note
*)
3519 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3526 else if (hdr
->p_filesz
> 0)
3528 bfd_set_error (bfd_error_no_memory
);
3535 /* Core files are simply standard ELF formatted files that partition
3536 the file using the execution view of the file (program header table)
3537 rather than the linking view. In fact, there is no section header
3538 table in a core file.
3540 The process status information (including the contents of the general
3541 register set) and the floating point register set are stored in a
3542 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3543 that allow standard bfd access to the general registers (.reg) and the
3544 floating point registers (.reg2).
3549 DEFUN (elf_core_file_p
, (abfd
), bfd
* abfd
)
3551 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3552 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3553 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3554 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3555 unsigned int phindex
;
3557 /* Read in the ELF header in external format. */
3559 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3561 bfd_set_error (bfd_error_system_call
);
3565 /* Now check to see if we have a valid ELF file, and one that BFD can
3566 make use of. The magic number must match, the address size ('class')
3567 and byte-swapping must match our XVEC entry, and it must have a
3568 program header table (FIXME: See comments re segments at top of this
3571 if (elf_file_p (&x_ehdr
) == false)
3574 bfd_set_error (bfd_error_wrong_format
);
3578 /* FIXME, Check EI_VERSION here ! */
3582 int desired_address_size
= ELFCLASS32
;
3585 int desired_address_size
= ELFCLASS64
;
3588 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3592 /* Switch xvec to match the specified byte order. */
3593 switch (x_ehdr
.e_ident
[EI_DATA
])
3595 case ELFDATA2MSB
: /* Big-endian */
3596 if (abfd
->xvec
->byteorder_big_p
== false)
3599 case ELFDATA2LSB
: /* Little-endian */
3600 if (abfd
->xvec
->byteorder_big_p
== true)
3603 case ELFDATANONE
: /* No data encoding specified */
3604 default: /* Unknown data encoding specified */
3608 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3609 the tdata pointer in the bfd. */
3612 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3613 if (elf_tdata (abfd
) == NULL
)
3615 bfd_set_error (bfd_error_no_memory
);
3619 /* FIXME, `wrong' returns from this point onward, leak memory. */
3621 /* Now that we know the byte order, swap in the rest of the header */
3622 i_ehdrp
= elf_elfheader (abfd
);
3623 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3625 elf_debug_file (i_ehdrp
);
3628 /* If there is no program header, or the type is not a core file, then
3630 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3633 /* Allocate space for a copy of the program header table in
3634 internal form, seek to the program header table in the file,
3635 read it in, and convert it to internal form. As a simple sanity
3636 check, verify that the what BFD thinks is the size of each program
3637 header table entry actually matches the size recorded in the file. */
3639 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3641 i_phdrp
= (Elf_Internal_Phdr
*)
3642 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3645 bfd_set_error (bfd_error_no_memory
);
3648 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3650 bfd_set_error (bfd_error_system_call
);
3653 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3655 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3658 bfd_set_error (bfd_error_system_call
);
3661 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3664 /* Once all of the program headers have been read and converted, we
3665 can start processing them. */
3667 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3669 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3670 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3672 elf_corefile_note (abfd
, i_phdrp
+ phindex
);
3676 /* Remember the entry point specified in the ELF file header. */
3678 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;