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
62 #include <string.h> /* For strrchr and friends */
68 /* Renaming structures, typedefs, macros and functions to be size-specific. */
69 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
70 #define Elf_External_Sym NAME(Elf,External_Sym)
71 #define Elf_External_Shdr NAME(Elf,External_Shdr)
72 #define Elf_External_Phdr NAME(Elf,External_Phdr)
73 #define Elf_External_Rel NAME(Elf,External_Rel)
74 #define Elf_External_Rela NAME(Elf,External_Rela)
76 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
77 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
78 #define elf_core_file_matches_executable_p NAME(bfd_elf,core_file_matches_executable_p)
79 #define elf_object_p NAME(bfd_elf,object_p)
80 #define elf_core_file_p NAME(bfd_elf,core_file_p)
81 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
82 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
83 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
84 #define elf_get_symtab NAME(bfd_elf,get_symtab)
85 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
86 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
87 #define elf_print_symbol NAME(bfd_elf,print_symbol)
88 #define elf_get_lineno NAME(bfd_elf,get_lineno)
89 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
90 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
91 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
92 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
93 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
94 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
95 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
96 #define write_relocs NAME(bfd_elf,_write_relocs)
97 #define elf_find_section NAME(bfd_elf,find_section)
100 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
101 #define ELF_R_SYM(X) ELF64_R_SYM(X)
102 #define ELFCLASS ELFCLASS64
106 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
107 #define ELF_R_SYM(X) ELF32_R_SYM(X)
108 #define ELFCLASS ELFCLASS32
112 static int shstrtab_length_fixed
;
120 /* Forward declarations of static functions */
122 static struct sec
*section_from_elf_index
PARAMS ((bfd
*, unsigned int));
124 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
126 static boolean elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**));
128 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
129 struct symbol_cache_entry
**));
131 static boolean elf_map_symbols
PARAMS ((bfd
*));
132 static boolean swap_out_syms
PARAMS ((bfd
*));
135 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
136 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
139 #define elf_string_from_elf_strtab(abfd,strindex) \
140 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
143 /* Structure swapping routines */
145 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
146 can be handled by explicitly specifying 32 bits or "the long type". */
148 #define put_word bfd_h_put_64
149 #define get_word bfd_h_get_64
152 #define put_word bfd_h_put_32
153 #define get_word bfd_h_get_32
156 /* Translate an ELF symbol in external format into an ELF symbol in internal
160 elf_swap_symbol_in (abfd
, src
, dst
)
162 Elf_External_Sym
*src
;
163 Elf_Internal_Sym
*dst
;
165 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
166 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
167 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
168 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
169 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
170 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
173 /* Translate an ELF symbol in internal format into an ELF symbol in external
177 elf_swap_symbol_out (abfd
, src
, dst
)
179 Elf_Internal_Sym
*src
;
180 Elf_External_Sym
*dst
;
182 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
183 put_word (abfd
, src
->st_value
, dst
->st_value
);
184 put_word (abfd
, src
->st_size
, dst
->st_size
);
185 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
186 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
187 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
191 /* Translate an ELF file header in external format into an ELF file header in
195 elf_swap_ehdr_in (abfd
, src
, dst
)
197 Elf_External_Ehdr
*src
;
198 Elf_Internal_Ehdr
*dst
;
200 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
201 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
202 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
203 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
204 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
205 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
206 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
207 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
208 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
209 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
210 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
211 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
212 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
213 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
216 /* Translate an ELF file header in internal format into an ELF file header in
220 elf_swap_ehdr_out (abfd
, src
, dst
)
222 Elf_Internal_Ehdr
*src
;
223 Elf_External_Ehdr
*dst
;
225 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
226 /* note that all elements of dst are *arrays of unsigned char* already... */
227 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
228 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
229 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
230 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
231 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
232 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
233 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
234 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
235 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
236 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
237 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
238 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
239 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
243 /* Translate an ELF section header table entry in external format into an
244 ELF section header table entry in internal format. */
247 elf_swap_shdr_in (abfd
, src
, dst
)
249 Elf_External_Shdr
*src
;
250 Elf_Internal_Shdr
*dst
;
252 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
253 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
254 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
255 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
256 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
257 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
258 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
259 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
260 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
261 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
262 /* we haven't done any processing on it yet, so... */
263 dst
->rawdata
= (void *) 0;
266 /* Translate an ELF section header table entry in internal format into an
267 ELF section header table entry in external format. */
270 elf_swap_shdr_out (abfd
, src
, dst
)
272 Elf_Internal_Shdr
*src
;
273 Elf_External_Shdr
*dst
;
275 /* note that all elements of dst are *arrays of unsigned char* already... */
276 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
277 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
278 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
279 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
280 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
281 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
282 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
283 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
284 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
285 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
289 /* Translate an ELF program header table entry in external format into an
290 ELF program header table entry in internal format. */
293 elf_swap_phdr_in (abfd
, src
, dst
)
295 Elf_External_Phdr
*src
;
296 Elf_Internal_Phdr
*dst
;
298 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
299 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
300 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
301 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
302 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
303 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
304 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
305 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
309 elf_swap_phdr_out (abfd
, src
, dst
)
311 Elf_Internal_Phdr
*src
;
312 Elf_External_Phdr
*dst
;
314 /* note that all elements of dst are *arrays of unsigned char* already... */
315 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
316 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
317 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
318 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
319 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
320 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
321 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
322 put_word (abfd
, src
->p_align
, dst
->p_align
);
325 /* Translate an ELF reloc from external format to internal format. */
327 elf_swap_reloc_in (abfd
, src
, dst
)
329 Elf_External_Rel
*src
;
330 Elf_Internal_Rel
*dst
;
332 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
333 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
337 elf_swap_reloca_in (abfd
, src
, dst
)
339 Elf_External_Rela
*src
;
340 Elf_Internal_Rela
*dst
;
342 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
343 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
344 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
347 /* Translate an ELF reloc from internal format to external format. */
349 elf_swap_reloc_out (abfd
, src
, dst
)
351 Elf_Internal_Rel
*src
;
352 Elf_External_Rel
*dst
;
354 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
355 put_word (abfd
, src
->r_info
, dst
->r_info
);
359 elf_swap_reloca_out (abfd
, src
, dst
)
361 Elf_Internal_Rela
*src
;
362 Elf_External_Rela
*dst
;
364 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
365 put_word (abfd
, src
->r_info
, dst
->r_info
);
366 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
371 /* String table creation/manipulation routines */
373 static struct strtab
*
374 bfd_new_strtab (abfd
)
379 ss
= (struct strtab
*) malloc (sizeof (struct strtab
));
382 bfd_set_error (bfd_error_no_memory
);
385 ss
->tab
= malloc (1);
388 bfd_set_error (bfd_error_no_memory
);
399 bfd_add_to_strtab (abfd
, ss
, str
)
404 /* should search first, but for now: */
405 /* include the trailing NUL */
406 int ln
= strlen (str
) + 1;
408 /* should this be using obstacks? */
409 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
411 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
412 strcpy (ss
->tab
+ ss
->length
, str
);
416 return ss
->length
- ln
;
420 bfd_add_2_to_strtab (abfd
, ss
, str
, str2
)
426 /* should search first, but for now: */
427 /* include the trailing NUL */
428 int ln
= strlen (str
) + strlen (str2
) + 1;
430 /* should this be using obstacks? */
432 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
434 ss
->tab
= malloc (ln
);
436 BFD_ASSERT (ss
->tab
!= 0); /* FIXME */
437 strcpy (ss
->tab
+ ss
->length
, str
);
438 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
442 return ss
->length
- ln
;
446 /* ELF .o/exec file reading */
448 /* Create a new bfd section from an ELF section header. */
451 bfd_section_from_shdr (abfd
, shindex
)
453 unsigned int shindex
;
455 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
456 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
460 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
462 switch (hdr
->sh_type
)
466 /* inactive section. Throw it away. */
471 /* Bits that get saved. This one is real. */
474 newsect
= bfd_make_section (abfd
, name
);
477 newsect
->filepos
= hdr
->sh_offset
; /* so we can read back the bits */
478 newsect
->flags
|= SEC_HAS_CONTENTS
;
479 newsect
->vma
= hdr
->sh_addr
;
480 newsect
->_raw_size
= hdr
->sh_size
;
481 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
483 if (hdr
->sh_flags
& SHF_ALLOC
)
485 newsect
->flags
|= SEC_ALLOC
;
486 newsect
->flags
|= SEC_LOAD
;
489 if (!(hdr
->sh_flags
& SHF_WRITE
))
490 newsect
->flags
|= SEC_READONLY
;
492 if (hdr
->sh_flags
& SHF_EXECINSTR
)
493 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
494 else if (newsect
->flags
& SEC_ALLOC
)
495 newsect
->flags
|= SEC_DATA
;
497 /* The debugging sections appear to recognized only by
499 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
500 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
501 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
502 newsect
->flags
|= SEC_DEBUGGING
;
504 hdr
->rawdata
= (void *) newsect
;
507 hdr
->rawdata
= (void *) bfd_get_section_by_name (abfd
, name
);
512 /* Bits that get saved. This one is real. */
515 newsect
= bfd_make_section (abfd
, name
);
518 newsect
->vma
= hdr
->sh_addr
;
519 newsect
->_raw_size
= hdr
->sh_size
;
520 newsect
->filepos
= hdr
->sh_offset
; /* fake */
521 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
522 if (hdr
->sh_flags
& SHF_ALLOC
)
523 newsect
->flags
|= SEC_ALLOC
;
525 if (!(hdr
->sh_flags
& SHF_WRITE
))
526 newsect
->flags
|= SEC_READONLY
;
528 /* FIXME: This section is empty. Does it really make
529 sense to set SEC_CODE for it? */
530 if (hdr
->sh_flags
& SHF_EXECINSTR
)
531 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
533 hdr
->rawdata
= (void *) newsect
;
538 case SHT_SYMTAB
: /* A symbol table */
539 if (elf_onesymtab (abfd
) == shindex
)
542 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
543 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
544 elf_onesymtab (abfd
) = shindex
;
545 elf_tdata (abfd
)->symtab_hdr
= *hdr
;
546 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->symtab_hdr
;
547 abfd
->flags
|= HAS_SYMS
;
550 case SHT_STRTAB
: /* A string table */
553 if (ehdr
->e_shstrndx
== shindex
)
555 elf_tdata (abfd
)->shstrtab_hdr
= *hdr
;
556 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->shstrtab_hdr
;
557 hdr
->rawdata
= (PTR
) & elf_tdata (abfd
)->shstrtab_hdr
;
563 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
565 Elf_Internal_Shdr
*hdr2
= elf_elfsections (abfd
)[i
];
566 if (hdr2
->sh_link
== shindex
)
568 bfd_section_from_shdr (abfd
, i
);
569 if (elf_onesymtab (abfd
) == i
)
571 elf_tdata (abfd
)->strtab_hdr
= *hdr
;
572 elf_elfsections (abfd
)[shindex
] = &elf_tdata (abfd
)->strtab_hdr
;
575 #if 0 /* Not handling other string tables specially right now. */
576 hdr2
= elf_elfsections (abfd
)[i
]; /* in case it moved */
577 /* We have a strtab for some random other section. */
578 newsect
= (asection
*) hdr2
->rawdata
;
581 hdr
->rawdata
= (PTR
) newsect
;
582 hdr2
= &elf_section_data (newsect
)->str_hdr
;
584 elf_elfsections (abfd
)[shindex
] = hdr2
;
590 newsect
= bfd_make_section (abfd
, name
);
593 newsect
->flags
= SEC_HAS_CONTENTS
;
594 hdr
->rawdata
= (PTR
) newsect
;
595 newsect
->_raw_size
= hdr
->sh_size
;
596 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
597 newsect
->vma
= hdr
->sh_addr
;
598 newsect
->filepos
= hdr
->sh_offset
;
600 if (hdr
->sh_flags
& SHF_ALLOC
)
601 newsect
->flags
|= SEC_ALLOC
| SEC_LOAD
;
602 if (!(hdr
->sh_flags
& SHF_WRITE
))
603 newsect
->flags
|= SEC_READONLY
;
604 if (hdr
->sh_flags
& SHF_EXECINSTR
)
605 newsect
->flags
|= SEC_CODE
;
606 else if (newsect
->flags
& SEC_ALLOC
)
607 newsect
->flags
|= SEC_DATA
;
609 /* Check for debugging string tables. */
610 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
611 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
612 newsect
->flags
|= SEC_DEBUGGING
;
619 /* *These* do a lot of work -- but build no sections!
620 The spec says there can be multiple strtabs, but only one symtab,
621 but there can be lots of REL* sections. */
622 /* FIXME: The above statement is wrong! There are typically at least
623 two symbol tables in a dynamically linked executable, ".dynsym"
624 which is the dynamic linkage symbol table and ".symtab", which is
625 the "traditional" symbol table. -fnf */
628 asection
*target_sect
;
629 Elf_Internal_Shdr
*hdr2
;
630 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
632 /* Don't allow REL relocations on a machine that uses RELA and
634 /* @@ Actually, the generic ABI does suggest that both might be
635 used in one file. But the four ABI Processor Supplements I
636 have access to right now all specify that only one is used on
637 each of those architectures. It's conceivable that, e.g., a
638 bunch of absolute 32-bit relocs might be more compact in REL
639 form even on a RELA machine... */
640 BFD_ASSERT (!(use_rela_p
&& (hdr
->sh_type
== SHT_REL
)));
641 BFD_ASSERT (!(!use_rela_p
&& (hdr
->sh_type
== SHT_RELA
)));
642 BFD_ASSERT (hdr
->sh_entsize
==
644 ? sizeof (Elf_External_Rela
)
645 : sizeof (Elf_External_Rel
)));
647 bfd_section_from_shdr (abfd
, hdr
->sh_info
); /* target */
648 bfd_section_from_shdr (abfd
, hdr
->sh_link
); /* symbol table */
649 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
650 if (target_sect
== NULL
651 || elf_section_data (target_sect
) == NULL
)
654 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
656 elf_elfsections (abfd
)[shindex
] = hdr2
;
657 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
658 target_sect
->flags
|= SEC_RELOC
;
659 target_sect
->relocation
= 0;
660 target_sect
->rel_filepos
= hdr
->sh_offset
;
661 abfd
->flags
|= HAS_RELOC
;
667 case SHT_DYNSYM
: /* could treat this like symtab... */
669 fprintf (stderr
, "Dynamic Linking sections not yet supported.\n");
676 fprintf (stderr
, "Note Sections not yet supported.\n");
683 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
688 /* Check for any processor-specific section types. */
690 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
692 if (bed
->elf_backend_section_from_shdr
)
693 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
702 elf_new_section_hook (abfd
, sec
)
707 struct bfd_elf_section_data
*sdata
;
709 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
712 bfd_set_error (bfd_error_no_memory
);
715 sec
->used_by_bfd
= (PTR
) sdata
;
716 memset (sdata
, 0, sizeof (*sdata
));
720 /* Create a new bfd section from an ELF program header.
722 Since program segments have no names, we generate a synthetic name
723 of the form segment<NUM>, where NUM is generally the index in the
724 program header table. For segments that are split (see below) we
725 generate the names segment<NUM>a and segment<NUM>b.
727 Note that some program segments may have a file size that is different than
728 (less than) the memory size. All this means is that at execution the
729 system must allocate the amount of memory specified by the memory size,
730 but only initialize it with the first "file size" bytes read from the
731 file. This would occur for example, with program segments consisting
732 of combined data+bss.
734 To handle the above situation, this routine generates TWO bfd sections
735 for the single program segment. The first has the length specified by
736 the file size of the segment, and the second has the length specified
737 by the difference between the two sizes. In effect, the segment is split
738 into it's initialized and uninitialized parts.
743 bfd_section_from_phdr (abfd
, hdr
, index
)
745 Elf_Internal_Phdr
*hdr
;
753 split
= ((hdr
->p_memsz
> 0) &&
754 (hdr
->p_filesz
> 0) &&
755 (hdr
->p_memsz
> hdr
->p_filesz
));
756 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
757 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
760 bfd_set_error (bfd_error_no_memory
);
763 strcpy (name
, namebuf
);
764 newsect
= bfd_make_section (abfd
, name
);
765 newsect
->vma
= hdr
->p_vaddr
;
766 newsect
->_raw_size
= hdr
->p_filesz
;
767 newsect
->filepos
= hdr
->p_offset
;
768 newsect
->flags
|= SEC_HAS_CONTENTS
;
769 if (hdr
->p_type
== PT_LOAD
)
771 newsect
->flags
|= SEC_ALLOC
;
772 newsect
->flags
|= SEC_LOAD
;
773 if (hdr
->p_flags
& PF_X
)
775 /* FIXME: all we known is that it has execute PERMISSION,
777 newsect
->flags
|= SEC_CODE
;
780 if (!(hdr
->p_flags
& PF_W
))
782 newsect
->flags
|= SEC_READONLY
;
787 sprintf (namebuf
, "segment%db", index
);
788 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
791 bfd_set_error (bfd_error_no_memory
);
794 strcpy (name
, namebuf
);
795 newsect
= bfd_make_section (abfd
, name
);
796 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
797 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
798 if (hdr
->p_type
== PT_LOAD
)
800 newsect
->flags
|= SEC_ALLOC
;
801 if (hdr
->p_flags
& PF_X
)
802 newsect
->flags
|= SEC_CODE
;
804 if (!(hdr
->p_flags
& PF_W
))
805 newsect
->flags
|= SEC_READONLY
;
811 /* Begin processing a given object.
813 First we validate the file by reading in the ELF header and checking
816 static INLINE boolean
818 Elf_External_Ehdr
*x_ehdrp
;
820 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
821 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
822 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
823 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
826 /* Check to see if the file associated with ABFD matches the target vector
829 Note that we may be called several times with the same ABFD, but different
830 target vectors, most of which will not match. We have to avoid leaving
831 any side effects in ABFD, or any data it points to (like tdata), if the
832 file does not match the target vector.
834 FIXME: There is memory leak if we are called more than once with the same
835 ABFD, and that bfd already has tdata allocated, since we allocate more tdata
836 and the old tdata is orphaned. Since it's in the bfd obstack, there isn't
837 much we can do about this except possibly rewrite the code. There are
838 also other bfd_allocs that may be the source of memory leaks as well. */
844 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
845 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
846 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
847 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
848 unsigned int shindex
;
849 char *shstrtab
; /* Internal copy of section header stringtab */
850 struct elf_backend_data
*ebd
;
851 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
853 /* Read in the ELF header in external format. */
855 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
856 goto got_system_call
;
858 /* Now check to see if we have a valid ELF file, and one that BFD can
859 make use of. The magic number must match, the address size ('class')
860 and byte-swapping must match our XVEC entry, and it must have a
861 section header table (FIXME: See comments re sections at top of this
864 if ((elf_file_p (&x_ehdr
) == false) ||
865 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
866 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
867 goto got_wrong_format_error
;
869 /* Check that file's byte order matches xvec's */
870 switch (x_ehdr
.e_ident
[EI_DATA
])
872 case ELFDATA2MSB
: /* Big-endian */
873 if (!abfd
->xvec
->header_byteorder_big_p
)
874 goto got_wrong_format_error
;
876 case ELFDATA2LSB
: /* Little-endian */
877 if (abfd
->xvec
->header_byteorder_big_p
)
878 goto got_wrong_format_error
;
880 case ELFDATANONE
: /* No data encoding specified */
881 default: /* Unknown data encoding specified */
882 goto got_wrong_format_error
;
885 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
886 the tdata pointer in the bfd. FIXME: memory leak, see above. */
889 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
890 if (elf_tdata (abfd
) == NULL
)
891 goto got_no_memory_error
;
893 /* Now that we know the byte order, swap in the rest of the header */
894 i_ehdrp
= elf_elfheader (abfd
);
895 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
897 elf_debug_file (i_ehdrp
);
900 /* If there is no section header table, we're hosed. */
901 if (i_ehdrp
->e_shoff
== 0)
902 goto got_wrong_format_error
;
904 /* As a simple sanity check, verify that the what BFD thinks is the
905 size of each section header table entry actually matches the size
906 recorded in the file. */
907 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
908 goto got_wrong_format_error
;
910 ebd
= get_elf_backend_data (abfd
);
912 /* Check that the ELF e_machine field matches what this particular
913 BFD format expects. */
914 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
916 bfd_target
**target_ptr
;
918 if (ebd
->elf_machine_code
!= EM_NONE
)
919 goto got_wrong_format_error
;
921 /* This is the generic ELF target. Let it match any ELF target
922 for which we do not have a specific backend. */
923 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
925 struct elf_backend_data
*back
;
927 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
929 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
930 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
932 /* target_ptr is an ELF backend which matches this
933 object file, so reject the generic ELF target. */
934 goto got_wrong_format_error
;
940 /* Set the flags and architecture before calling the backend so that
941 it can override them. */
942 if (i_ehdrp
->e_type
== ET_EXEC
)
943 abfd
->flags
|= EXEC_P
;
944 else if (i_ehdrp
->e_type
== ET_DYN
)
945 abfd
->flags
|= DYNAMIC
;
947 bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0);
949 /* Remember the entry point specified in the ELF file header. */
950 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
952 /* Let the backend double check the format and override global
954 if (ebd
->elf_backend_object_p
)
956 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
957 goto got_wrong_format_error
;
960 /* Allocate space for a copy of the section header table in
961 internal form, seek to the section header table in the file,
962 read it in, and convert it to internal form. */
963 i_shdrp
= (Elf_Internal_Shdr
*)
964 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
);
965 elf_elfsections (abfd
) =
966 (Elf_Internal_Shdr
**) bfd_alloc (abfd
, sizeof (i_shdrp
) * i_ehdrp
->e_shnum
);
967 if (!i_shdrp
|| !elf_elfsections (abfd
))
968 goto got_no_memory_error
;
969 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) == -1)
970 goto got_system_call
;
971 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
973 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
974 goto got_system_call
;
975 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
976 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
978 /* If this is a .dynamic section, mark the object file as being
979 dynamically linked. */
980 if (i_shdrp
[shindex
].sh_type
== SHT_DYNAMIC
)
981 abfd
->flags
|= DYNAMIC
;
983 if (i_ehdrp
->e_shstrndx
)
985 bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
);
988 /* Read in the string table containing the names of the sections. We
989 will need the base pointer to this table later. */
990 /* We read this inline now, so that we don't have to go through
991 bfd_section_from_shdr with it (since this particular strtab is
992 used to find all of the ELF section names.) */
994 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
996 goto got_wrong_format_error
;
998 /* Once all of the section headers have been read and converted, we
999 can start processing them. Note that the first section header is
1000 a dummy placeholder entry, so we ignore it.
1002 We also watch for the symbol table section and remember the file
1003 offset and section size for both the symbol table section and the
1004 associated string table section. */
1006 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1008 bfd_section_from_shdr (abfd
, shindex
);
1011 return (abfd
->xvec
);
1013 /* If we are going to use goto's to avoid duplicating error setting
1014 and return(NULL) code, then this at least makes it more maintainable. */
1017 bfd_set_error (bfd_error_system_call
);
1019 got_wrong_format_error
:
1020 bfd_set_error (bfd_error_wrong_format
);
1022 got_no_memory_error
:
1023 bfd_set_error (bfd_error_no_memory
);
1026 elf_tdata (abfd
) = preserved_tdata
;
1031 /* ELF .o/exec file writing */
1033 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1034 of the symbol if there is one. */
1035 static INLINE elf_symbol_type
*
1036 elf_symbol_from (ignore_abfd
, symbol
)
1040 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1043 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1046 return (elf_symbol_type
*) symbol
;
1049 /* Create ELF output from BFD sections.
1051 Essentially, just create the section header and forget about the program
1055 elf_make_sections (abfd
, asect
, obj
)
1060 /* most of what is in bfd_shdr_from_section goes in here... */
1061 /* and all of these sections generate at *least* one ELF section. */
1062 Elf_Internal_Shdr
*this_hdr
;
1063 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1065 this_hdr
->sh_addr
= asect
->vma
;
1066 this_hdr
->sh_size
= asect
->_raw_size
;
1067 /* contents already set by elf_set_section_contents */
1069 if (asect
->flags
& SEC_RELOC
)
1071 /* emit a reloc section, and thus strtab and symtab... */
1072 Elf_Internal_Shdr
*rela_hdr
;
1073 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1075 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1077 /* orelocation has the data, reloc_count has the count... */
1080 rela_hdr
->sh_type
= SHT_RELA
;
1081 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1084 /* REL relocations */
1086 rela_hdr
->sh_type
= SHT_REL
;
1087 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1089 rela_hdr
->sh_flags
= 0;
1090 rela_hdr
->sh_addr
= 0;
1091 rela_hdr
->sh_offset
= 0;
1093 /* FIXME: Systems I've checked use an alignment of 4, but it is
1094 possible that some systems use a different alignment. */
1095 rela_hdr
->sh_addralign
= 4;
1099 if (asect
->flags
& SEC_ALLOC
)
1101 this_hdr
->sh_flags
|= SHF_ALLOC
;
1102 if (asect
->flags
& SEC_LOAD
)
1104 /* @@ Do something with sh_type? */
1109 /* If this section is not part of the program image during
1110 execution, leave the address fields at 0. */
1111 this_hdr
->sh_addr
= 0;
1114 if (!(asect
->flags
& SEC_READONLY
))
1115 this_hdr
->sh_flags
|= SHF_WRITE
;
1117 if (asect
->flags
& SEC_CODE
)
1118 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1122 write_relocs (abfd
, sec
, xxx
)
1127 Elf_Internal_Shdr
*rela_hdr
;
1128 Elf_External_Rela
*outbound_relocas
;
1129 Elf_External_Rel
*outbound_relocs
;
1131 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1132 asymbol
*last_sym
= 0;
1133 int last_sym_idx
= 9999999; /* should always be written before use */
1135 if ((sec
->flags
& SEC_RELOC
) == 0)
1137 /* Flags are sometimes inconsistent. */
1138 if (sec
->reloc_count
== 0)
1141 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1143 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1144 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1145 if (!rela_hdr
->contents
)
1147 bfd_set_error (bfd_error_no_memory
);
1148 abort (); /* FIXME */
1151 /* orelocation has the data, reloc_count has the count... */
1154 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1156 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1158 Elf_Internal_Rela dst_rela
;
1159 Elf_External_Rela
*src_rela
;
1164 ptr
= sec
->orelocation
[idx
];
1165 src_rela
= outbound_relocas
+ idx
;
1166 if (!(abfd
->flags
& EXEC_P
))
1167 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1169 dst_rela
.r_offset
= ptr
->address
;
1171 sym
= *ptr
->sym_ptr_ptr
;
1172 if (sym
== last_sym
)
1177 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1179 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1181 dst_rela
.r_addend
= ptr
->addend
;
1182 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1186 /* REL relocations */
1188 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1190 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1192 Elf_Internal_Rel dst_rel
;
1193 Elf_External_Rel
*src_rel
;
1198 ptr
= sec
->orelocation
[idx
];
1199 sym
= *ptr
->sym_ptr_ptr
;
1200 src_rel
= outbound_relocs
+ idx
;
1201 if (!(abfd
->flags
& EXEC_P
))
1202 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1204 dst_rel
.r_offset
= ptr
->address
;
1206 if (sym
== last_sym
)
1211 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1213 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1215 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1221 fix_up_strtabs (abfd
, asect
, obj
)
1226 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (asect
)->this_hdr
;
1227 int this_idx
= elf_section_data (asect
)->this_idx
;
1229 /* @@ Check flags! */
1230 if (!strncmp (asect
->name
, ".stab", 5)
1231 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
1233 size_t len
= strlen (asect
->name
) + 1;
1234 char *s
= (char *) malloc (len
);
1236 /* FIXME: Should deal more gracefully with errors. */
1238 strcpy (s
, asect
->name
);
1240 asect
= bfd_get_section_by_name (abfd
, s
);
1244 elf_section_data (asect
)->this_hdr
.sh_link
= this_idx
;
1245 /* @@ Assuming 32 bits! */
1246 elf_section_data (asect
)->this_hdr
.sh_entsize
= 0xc;
1248 this_hdr
->sh_type
= SHT_STRTAB
;
1253 elf_fake_sections (abfd
, asect
, obj
)
1258 /* most of what is in bfd_shdr_from_section goes in here... */
1259 /* and all of these sections generate at *least* one ELF section. */
1261 Elf_Internal_Shdr
*this_hdr
;
1262 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1264 bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
), asect
->name
);
1265 /* We need to log the type *now* so that elf_section_from_bfd_section
1266 can find us... have to set rawdata too. */
1267 this_hdr
->rawdata
= (void *) asect
;
1268 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1269 if ((asect
->flags
& SEC_ALLOC
) && (asect
->flags
& SEC_LOAD
))
1270 this_hdr
->sh_type
= SHT_PROGBITS
;
1271 else if ((asect
->flags
& SEC_ALLOC
) && ((asect
->flags
& SEC_LOAD
) == 0))
1273 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1274 || strcmp (asect
->name
, ".sbss") == 0);
1275 this_hdr
->sh_type
= SHT_NOBITS
;
1277 /* FIXME I am not sure how to detect a .note section from the flags
1278 word of an `asection'. */
1279 else if (!strcmp (asect
->name
, ".note"))
1280 this_hdr
->sh_type
= SHT_NOTE
;
1282 this_hdr
->sh_type
= SHT_PROGBITS
;
1284 this_hdr
->sh_flags
= 0;
1285 this_hdr
->sh_addr
= 0;
1286 this_hdr
->sh_size
= 0;
1287 this_hdr
->sh_entsize
= 0;
1288 this_hdr
->sh_info
= 0;
1289 this_hdr
->sh_link
= 0;
1290 this_hdr
->sh_offset
= 0;
1293 /* Now, check for processor-specific section types. */
1295 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1297 if (bed
->elf_backend_fake_sections
)
1298 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1302 /* Emit a strtab and symtab, and possibly a reloc section. */
1303 Elf_Internal_Shdr
*rela_hdr
;
1305 /* Note that only one symtab is used, so just remember it
1308 if (asect
->flags
& SEC_RELOC
)
1310 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1312 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1314 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1315 use_rela_p
? ".rela" : ".rel",
1317 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1318 rela_hdr
->sh_entsize
= (use_rela_p
1319 ? sizeof (Elf_External_Rela
)
1320 : sizeof (Elf_External_Rel
));
1322 rela_hdr
->sh_flags
= 0;
1323 rela_hdr
->sh_addr
= 0;
1324 rela_hdr
->sh_size
= 0;
1325 rela_hdr
->sh_offset
= 0;
1327 /* FIXME: Systems I've checked use an alignment of 4, but some
1328 systems may use a different alignment. */
1329 rela_hdr
->sh_addralign
= 4;
1334 if (asect
->flags
& SEC_ALLOC
)
1336 this_hdr
->sh_flags
|= SHF_ALLOC
;
1337 if (asect
->flags
& SEC_LOAD
)
1339 /* @@ Do something with sh_type? */
1342 if (!(asect
->flags
& SEC_READONLY
))
1343 this_hdr
->sh_flags
|= SHF_WRITE
;
1344 if (asect
->flags
& SEC_CODE
)
1345 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1348 /* Map symbol from it's internal number to the external number, moving
1349 all local symbols to be at the head of the list. */
1352 sym_is_global (abfd
, sym
)
1356 /* If the backend has a special mapping, use it. */
1357 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1358 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1361 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1363 if (sym
->flags
& BSF_LOCAL
)
1367 if (sym
->section
== 0)
1369 /* Is this valid? */
1374 if (sym
->section
== &bfd_und_section
)
1376 if (bfd_is_com_section (sym
->section
))
1378 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1384 elf_map_symbols (abfd
)
1387 int symcount
= bfd_get_symcount (abfd
);
1388 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1389 asymbol
**sect_syms
;
1391 int num_globals
= 0;
1392 int num_locals2
= 0;
1393 int num_globals2
= 0;
1395 int num_sections
= 0;
1396 Elf_Sym_Extra
*sym_extra
;
1401 fprintf (stderr
, "elf_map_symbols\n");
1405 /* Add local symbols for each section for which there are relocs.
1406 FIXME: How can we tell which sections have relocs at this point?
1407 Will reloc_count always be accurate? Actually, I think most ELF
1408 targets create section symbols for all sections anyhow. */
1409 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1411 if (max_index
< asect
->index
)
1412 max_index
= asect
->index
;
1416 elf_num_section_syms (abfd
) = max_index
;
1417 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1418 elf_section_syms (abfd
) = sect_syms
;
1422 bfd_set_error (bfd_error_no_memory
);
1426 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1428 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1431 bfd_set_error (bfd_error_no_memory
);
1434 sym
->the_bfd
= abfd
;
1435 sym
->name
= asect
->name
;
1436 sym
->value
= asect
->vma
;
1437 sym
->flags
= BSF_SECTION_SYM
;
1438 sym
->section
= asect
;
1439 sect_syms
[asect
->index
] = sym
;
1443 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1444 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1451 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1452 ((symcount
+ num_sections
+ 1)
1453 * sizeof (asymbol
*)));
1455 syms
= (asymbol
**) bfd_alloc (abfd
,
1456 (num_sections
+ 1) * sizeof (asymbol
*));
1459 bfd_set_error (bfd_error_no_memory
);
1463 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1465 if (sect_syms
[asect
->index
])
1466 syms
[symcount
++] = sect_syms
[asect
->index
];
1469 syms
[symcount
] = (asymbol
*) 0;
1470 bfd_set_symtab (abfd
, syms
, symcount
);
1473 elf_sym_extra (abfd
) = sym_extra
1474 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1477 bfd_set_error (bfd_error_no_memory
);
1481 /* Identify and classify all of the symbols. */
1482 for (idx
= 0; idx
< symcount
; idx
++)
1484 if (!sym_is_global (abfd
, syms
[idx
]))
1490 /* Now provide mapping information. Add +1 for skipping over the
1492 for (idx
= 0; idx
< symcount
; idx
++)
1494 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1495 if (!sym_is_global (abfd
, syms
[idx
]))
1496 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1498 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1501 elf_num_locals (abfd
) = num_locals
;
1502 elf_num_globals (abfd
) = num_globals
;
1506 static boolean
assign_section_numbers ();
1507 static boolean
assign_file_positions_except_relocs ();
1510 elf_compute_section_file_positions (abfd
)
1513 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1515 if (!assign_section_numbers (abfd
))
1518 bfd_map_over_sections (abfd
, elf_make_sections
, 0);
1520 bfd_map_over_sections (abfd
, fix_up_strtabs
, 0); /* .stab/.stabstr &c */
1522 if (swap_out_syms (abfd
) == false)
1525 if (!assign_file_positions_except_relocs (abfd
))
1532 elf_write_phdrs (abfd
, i_ehdrp
, i_phdrp
, phdr_cnt
)
1534 Elf_Internal_Ehdr
*i_ehdrp
;
1535 Elf_Internal_Phdr
*i_phdrp
;
1536 unsigned short phdr_cnt
;
1538 /* first program header entry goes after the file header */
1539 int outbase
= i_ehdrp
->e_phoff
;
1541 Elf_External_Phdr x_phdr
;
1543 for (i
= 0; i
< phdr_cnt
; i
++)
1545 elf_swap_phdr_out (abfd
, i_phdrp
+ i
, &x_phdr
);
1546 bfd_seek (abfd
, outbase
, SEEK_SET
);
1547 bfd_write ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
);
1548 outbase
+= sizeof (x_phdr
);
1554 static const Elf_Internal_Shdr null_shdr
;
1556 /* Assign all ELF section numbers. The dummy first section is handled here
1557 too. The link/info pointers for the standard section types are filled
1558 in here too, while we're at it. (Link pointers for .stab sections are
1559 not filled in here.) */
1561 assign_section_numbers (abfd
)
1564 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1566 int section_number
= 1;
1568 Elf_Internal_Shdr
**i_shdrp
;
1570 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1571 t
->shstrtab_hdr
.contents
= (void *) elf_shstrtab (abfd
)->tab
;
1572 shstrtab_length_fixed
= 1;
1574 t
->shstrtab_section
= section_number
++;
1575 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1578 t
->symtab_section
= section_number
++;
1579 t
->strtab_section
= section_number
++;
1580 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1582 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1584 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1585 d
->this_idx
= section_number
++;
1586 if (sec
->flags
& SEC_RELOC
)
1588 d
->rel_idx
= section_number
++;
1589 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1590 d
->rel_hdr
.sh_info
= d
->this_idx
;
1594 /* No handling for per-section string tables currently. */
1596 elf_elfheader (abfd
)->e_shnum
= section_number
;
1598 /* Set up the list of section header pointers, in agreement with the
1600 i_shdrp
= (Elf_Internal_Shdr
**)
1601 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*));
1604 bfd_set_error (bfd_error_no_memory
);
1607 elf_elfsections (abfd
) = i_shdrp
;
1608 for (i
= 0; i
< section_number
; i
++)
1611 i_shdrp
[0] = (Elf_Internal_Shdr
*) & null_shdr
;
1612 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1615 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1616 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1618 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1620 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1621 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1623 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1625 /* Make sure we got everything.... */
1626 for (i
= 0; i
< section_number
; i
++)
1627 if (i_shdrp
[i
] == 0)
1632 static INLINE file_ptr
1633 assign_file_position_for_section (i_shdrp
, offset
)
1634 Elf_Internal_Shdr
*i_shdrp
;
1639 if (i_shdrp
->sh_addralign
!= 0)
1640 align
= i_shdrp
->sh_addralign
;
1643 i_shdrp
->sh_offset
= offset
= BFD_ALIGN (offset
, align
);
1644 if (i_shdrp
->rawdata
!= NULL
)
1645 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1646 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1647 offset
+= i_shdrp
->sh_size
;
1651 static INLINE file_ptr
1652 align_file_position (off
)
1655 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1658 static INLINE file_ptr
1659 assign_file_positions_for_symtab_and_strtabs (abfd
, off
)
1663 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1665 off
= align_file_position (off
);
1666 off
= assign_file_position_for_section (&t
->symtab_hdr
, off
);
1667 off
= assign_file_position_for_section (&t
->shstrtab_hdr
, off
);
1668 off
= assign_file_position_for_section (&t
->strtab_hdr
, off
);
1674 bfd_vma low
, mem_size
;
1678 struct seg_info
*next
;
1682 map_program_segments (abfd
)
1685 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1686 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1687 Elf_Internal_Shdr
*i_shdrp
;
1688 Elf_Internal_Phdr
*phdr
;
1690 unsigned int i
, n_left
= 0;
1691 file_ptr lowest_offset
= 0;
1692 struct seg_info
*seg
= NULL
;
1694 done
= (char *) malloc (i_ehdrp
->e_shnum
);
1697 bfd_set_error (bfd_error_no_memory
);
1700 memset (done
, 0, i_ehdrp
->e_shnum
);
1701 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1703 i_shdrp
= i_shdrpp
[i
];
1704 /* If it's going to be mapped in, it's been assigned a position. */
1705 if (i_shdrp
->sh_offset
+ 1 == 0)
1707 /* Well, not really, but we won't process it here. */
1711 if (i_shdrp
->sh_offset
< lowest_offset
1712 || lowest_offset
== 0)
1713 lowest_offset
= i_shdrp
->sh_offset
;
1714 /* Only interested in PROGBITS or NOBITS for generating segments. */
1715 switch (i_shdrp
->sh_type
)
1728 bfd_vma lowest_vma
= -1, high
;
1732 struct seg_info
*snew
;
1733 struct seg_info
**s_ptr
;
1735 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1737 i_shdrp
= i_shdrpp
[i
];
1738 if (!done
[i
] && i_shdrp
->sh_addr
< lowest_vma
)
1740 lowest_vma
= i_shdrp
->sh_addr
;
1746 /* So now we know the lowest vma of any unassigned sections; start
1748 snew
= (struct seg_info
*) bfd_alloc (abfd
, sizeof (struct seg_info
));
1751 bfd_set_error (bfd_error_no_memory
);
1755 while (*s_ptr
!= (struct seg_info
*) NULL
)
1756 s_ptr
= &(*s_ptr
)->next
;
1759 snew
->low
= lowest_vma
;
1760 i_shdrp
= i_shdrpp
[low_sec
];
1761 snew
->start_pos
= i_shdrp
->sh_offset
;
1762 snew
->sh_flags
= i_shdrp
->sh_flags
;
1763 done
[low_sec
] = 1, n_left
--;
1764 mem_size
= i_shdrp
->sh_size
;
1765 high
= lowest_vma
+ i_shdrp
->sh_size
;
1767 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1768 file_size
= i_shdrp
->sh_size
;
1770 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1776 i_shdrp
= i_shdrpp
[i
];
1777 /* position of next byte on disk */
1778 f1
= snew
->start_pos
+ file_size
;
1779 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1781 if (i_shdrp
->sh_offset
- f1
!= i_shdrp
->sh_addr
- high
)
1783 if (file_size
!= mem_size
)
1787 /* sh_type == NOBITS */
1789 /* If the section in question has no contents in the disk
1790 file, we really don't care where it supposedly starts.
1791 But we don't want to bother merging it into this segment
1792 if it doesn't start on this memory page. */
1793 bfd_vma page1
, page2
;
1794 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1796 /* page number in address space of current end of snew */
1797 page1
= (high
- 1 + maxpagesize
- 1) / maxpagesize
;
1798 /* page number in address space of start of this section */
1799 page2
= (i_shdrp
->sh_addr
+ maxpagesize
- 1) / maxpagesize
;
1804 done
[i
] = 1, n_left
--;
1805 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1806 file_size
= i_shdrp
->sh_offset
+ i_shdrp
->sh_size
- snew
->start_pos
;
1807 mem_size
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
- snew
->low
;
1808 high
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
;
1811 snew
->file_size
= file_size
;
1812 snew
->mem_size
= mem_size
;
1814 /* Now do something with the list of segments we've built up. */
1816 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1821 for (s
= seg
; s
; s
= s
->next
)
1825 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1826 sz
= sizeof (Elf_External_Phdr
) * n_segs
;
1827 if (align_file_position (i_ehdrp
->e_ehsize
) + sz
<= lowest_offset
)
1828 i_ehdrp
->e_phoff
= align_file_position (i_ehdrp
->e_ehsize
);
1831 i_ehdrp
->e_phoff
= align_file_position (elf_tdata (abfd
)->next_file_pos
);
1832 elf_tdata (abfd
)->next_file_pos
= i_ehdrp
->e_phoff
+ sz
;
1834 phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
,
1835 n_segs
* sizeof (Elf_Internal_Phdr
));
1838 bfd_set_error (bfd_error_no_memory
);
1839 abort (); /* FIXME */
1841 elf_tdata (abfd
)->phdr
= phdr
;
1844 phdr
->p_type
= PT_LOAD
; /* only type we really support so far */
1845 phdr
->p_offset
= seg
->start_pos
;
1846 phdr
->p_vaddr
= seg
->low
;
1848 phdr
->p_filesz
= seg
->file_size
;
1849 phdr
->p_memsz
= seg
->mem_size
;
1850 phdr
->p_flags
= PF_R
;
1851 phdr
->p_align
= maxpagesize
; /* ? */
1852 if (seg
->sh_flags
& SHF_WRITE
)
1853 /* SysVr4 ELF docs say "data segments normally have read, write,
1854 and execute permissions." */
1855 phdr
->p_flags
|= (PF_W
| PF_X
);
1856 if (seg
->sh_flags
& SHF_EXECINSTR
)
1857 phdr
->p_flags
|= PF_X
;
1861 i_ehdrp
->e_phnum
= n_segs
;
1863 elf_write_phdrs (abfd
, i_ehdrp
, elf_tdata (abfd
)->phdr
, i_ehdrp
->e_phnum
);
1874 assign_file_positions_except_relocs (abfd
)
1877 /* For now, we ignore the possibility of having program segments, which
1878 may require some alignment in the file. That'll require padding, and
1879 some interesting calculations to optimize file space usage.
1881 Also, since the application may change the list of relocations for
1882 a given section, we don't figure them in here. We'll put them at the
1883 end of the file, at positions computed during bfd_close.
1885 The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
1886 or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
1888 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1891 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1892 Elf_Internal_Shdr
*i_shdrp
;
1893 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1894 int exec_p
= (abfd
->flags
& EXEC_P
) != 0;
1895 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1897 /* Everything starts after the ELF file header. */
1898 off
= i_ehdrp
->e_ehsize
;
1902 /* Section headers. */
1903 off
= align_file_position (off
);
1904 i_ehdrp
->e_shoff
= off
;
1905 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1906 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1908 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1910 /* The symtab and strtab sections are placed by
1911 assign_file_positions_for_symtab_and_strtabs. */
1912 if (i
== t
->symtab_section
1913 || i
== t
->strtab_section
1914 || i
== t
->shstrtab_section
)
1917 i_shdrp
= i_shdrpp
[i
];
1918 if (i_shdrp
->sh_type
== SHT_REL
|| i_shdrp
->sh_type
== SHT_RELA
)
1920 i_shdrp
->sh_offset
= -1;
1925 if (maxpagesize
== 0)
1926 maxpagesize
= 1; /* make the arithmetic work */
1927 /* This isn't necessarily going to give the best packing, if the
1928 segments require padding between them, but since that isn't
1929 usually the case, this'll do. */
1930 if ((i_shdrp
->sh_flags
& SHF_ALLOC
) == 0)
1932 i_shdrp
->sh_offset
= -1;
1935 /* Blindly assume that the segments are ordered optimally. With
1936 the default LD script, they will be. */
1937 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1939 /* need big unsigned type */
1941 addtl_off
= i_shdrp
->sh_addr
- off
;
1942 addtl_off
= addtl_off
% maxpagesize
;
1949 off
= assign_file_position_for_section (i_shdrp
, off
);
1952 && i_shdrp
->sh_type
== SHT_NOBITS
1953 && (i
== i_ehdrp
->e_shnum
1954 || i_shdrpp
[i
+ 1]->sh_type
!= SHT_NOBITS
))
1956 /* Skip to the next page to ensure that when the file is
1957 loaded the bss section is loaded with zeroes. I don't
1958 know if this is required on all platforms, but it
1959 shouldn't really hurt. */
1960 off
= BFD_ALIGN (off
, maxpagesize
);
1964 && get_elf_backend_data (abfd
)->maxpagesize
> 1
1965 && i_shdrp
->sh_type
== SHT_PROGBITS
1966 && (i_shdrp
->sh_flags
& SHF_ALLOC
)
1967 && (i_shdrp
->sh_offset
- i_shdrp
->sh_addr
) % get_elf_backend_data (abfd
)->maxpagesize
!= 0)
1972 elf_tdata (abfd
)->next_file_pos
= off
;
1973 if (!map_program_segments (abfd
))
1975 off
= elf_tdata (abfd
)->next_file_pos
;
1977 /* Section headers. */
1978 off
= align_file_position (off
);
1979 i_ehdrp
->e_shoff
= off
;
1980 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1982 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1984 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1986 i_shdrp
= i_shdrpp
[i
];
1987 if (i_shdrp
->sh_offset
+ 1 == 0
1988 && i_shdrp
->sh_type
!= SHT_REL
1989 && i_shdrp
->sh_type
!= SHT_RELA
)
1990 off
= assign_file_position_for_section (i_shdrp
, off
);
1993 elf_tdata (abfd
)->next_file_pos
= off
;
2001 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2002 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2003 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2005 struct strtab
*shstrtab
;
2007 i_ehdrp
= elf_elfheader (abfd
);
2008 i_shdrp
= elf_elfsections (abfd
);
2010 shstrtab
= bfd_new_strtab (abfd
);
2014 elf_shstrtab (abfd
) = shstrtab
;
2016 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2017 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2018 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2019 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2021 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2022 i_ehdrp
->e_ident
[EI_DATA
] =
2023 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2024 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2026 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2027 i_ehdrp
->e_ident
[count
] = 0;
2029 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
2030 switch (bfd_get_arch (abfd
))
2032 case bfd_arch_unknown
:
2033 i_ehdrp
->e_machine
= EM_NONE
;
2035 case bfd_arch_sparc
:
2036 i_ehdrp
->e_machine
= EM_SPARC
;
2037 /* start-sanitize-v9 */
2039 i_ehdrp
->e_machine
= EM_SPARC64
;
2041 /* end-sanitize-v9 */
2044 i_ehdrp
->e_machine
= EM_386
;
2047 i_ehdrp
->e_machine
= EM_68K
;
2050 i_ehdrp
->e_machine
= EM_88K
;
2053 i_ehdrp
->e_machine
= EM_860
;
2055 case bfd_arch_mips
: /* MIPS Rxxxx */
2056 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2059 i_ehdrp
->e_machine
= EM_HPPA
;
2061 case bfd_arch_powerpc
:
2062 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2064 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2066 i_ehdrp
->e_machine
= EM_NONE
;
2068 i_ehdrp
->e_version
= EV_CURRENT
;
2069 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2071 /* no program header, for now. */
2072 i_ehdrp
->e_phoff
= 0;
2073 i_ehdrp
->e_phentsize
= 0;
2074 i_ehdrp
->e_phnum
= 0;
2076 /* each bfd section is section header entry */
2077 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2078 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2080 /* if we're building an executable, we'll need a program header table */
2081 if (abfd
->flags
& EXEC_P
)
2083 /* it all happens later */
2085 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2087 /* elf_build_phdrs() returns a (NULL-terminated) array of
2088 Elf_Internal_Phdrs */
2089 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2090 i_ehdrp
->e_phoff
= outbase
;
2091 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2096 i_ehdrp
->e_phentsize
= 0;
2098 i_ehdrp
->e_phoff
= 0;
2101 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2103 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2105 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2111 swap_out_syms (abfd
)
2114 if (!elf_map_symbols (abfd
))
2117 /* Dump out the symtabs. */
2119 int symcount
= bfd_get_symcount (abfd
);
2120 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2121 struct strtab
*stt
= bfd_new_strtab (abfd
);
2122 Elf_Internal_Shdr
*symtab_hdr
;
2123 Elf_Internal_Shdr
*symstrtab_hdr
;
2124 Elf_External_Sym
*outbound_syms
;
2129 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2130 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2131 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2132 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2133 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2135 /* FIXME: Systems I've checked use 4 byte alignment for .symtab,
2136 but it is possible that there are systems which use a different
2138 symtab_hdr
->sh_addralign
= 4;
2140 /* see assert in elf_fake_sections that supports this: */
2141 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2142 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2144 outbound_syms
= (Elf_External_Sym
*)
2145 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2148 bfd_set_error (bfd_error_no_memory
);
2151 /* now generate the data (for "contents") */
2153 /* Fill in zeroth symbol and swap it out. */
2154 Elf_Internal_Sym sym
;
2160 sym
.st_shndx
= SHN_UNDEF
;
2161 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2163 for (idx
= 0; idx
< symcount
; idx
++)
2165 Elf_Internal_Sym sym
;
2166 bfd_vma value
= syms
[idx
]->value
;
2168 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2169 /* Section symbols have no names. */
2172 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2174 if (bfd_is_com_section (syms
[idx
]->section
))
2176 /* ELF common symbols put the alignment into the `value' field,
2177 and the size into the `size' field. This is backwards from
2178 how BFD handles it, so reverse it here. */
2179 sym
.st_size
= value
;
2180 /* Should retrieve this from somewhere... */
2182 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2183 syms
[idx
]->section
);
2187 asection
*sec
= syms
[idx
]->section
;
2188 elf_symbol_type
*type_ptr
;
2191 if (sec
->output_section
)
2193 value
+= sec
->output_offset
;
2194 sec
= sec
->output_section
;
2197 sym
.st_value
= value
;
2198 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2199 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2200 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2204 /* Writing this would be a hell of a lot easier if we had
2205 some decent documentation on bfd, and knew what to expect
2206 of the library, and what to demand of applications. For
2207 example, it appears that `objcopy' might not set the
2208 section of a symbol to be a section that is actually in
2210 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2211 BFD_ASSERT (sec2
!= 0);
2212 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2213 BFD_ASSERT (shndx
!= -1);
2217 if (bfd_is_com_section (syms
[idx
]->section
))
2218 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2219 else if (syms
[idx
]->section
== &bfd_und_section
)
2220 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2221 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2222 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2223 else if (syms
[idx
]->flags
& BSF_FILE
)
2224 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2227 int bind
= STB_LOCAL
;
2228 int type
= STT_OBJECT
;
2229 unsigned int flags
= syms
[idx
]->flags
;
2231 if (flags
& BSF_LOCAL
)
2233 else if (flags
& BSF_WEAK
)
2235 else if (flags
& BSF_GLOBAL
)
2238 if (flags
& BSF_FUNCTION
)
2241 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2245 elf_swap_symbol_out (abfd
, &sym
,
2247 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2250 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2251 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2252 symstrtab_hdr
->sh_size
= stt
->length
;
2253 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2255 symstrtab_hdr
->sh_flags
= 0;
2256 symstrtab_hdr
->sh_addr
= 0;
2257 symstrtab_hdr
->sh_entsize
= 0;
2258 symstrtab_hdr
->sh_link
= 0;
2259 symstrtab_hdr
->sh_info
= 0;
2260 symstrtab_hdr
->sh_addralign
= 1;
2261 symstrtab_hdr
->size
= 0;
2264 /* put the strtab out too... */
2266 Elf_Internal_Shdr
*this_hdr
;
2268 this_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2269 this_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
2270 this_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
2271 this_hdr
->sh_type
= SHT_STRTAB
;
2272 this_hdr
->sh_flags
= 0;
2273 this_hdr
->sh_addr
= 0;
2274 this_hdr
->sh_entsize
= 0;
2275 this_hdr
->sh_addralign
= 1;
2282 write_shdrs_and_ehdr (abfd
)
2285 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2286 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2287 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2288 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2290 struct strtab
*shstrtab
;
2292 i_ehdrp
= elf_elfheader (abfd
);
2293 i_shdrp
= elf_elfsections (abfd
);
2294 shstrtab
= elf_shstrtab (abfd
);
2296 /* swap the header before spitting it out... */
2299 elf_debug_file (i_ehdrp
);
2301 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2302 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
2303 bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
);
2305 /* at this point we've concocted all the ELF sections... */
2306 x_shdrp
= (Elf_External_Shdr
*)
2307 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2310 bfd_set_error (bfd_error_no_memory
);
2314 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2317 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2320 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2322 bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
);
2323 bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
);
2324 /* need to dump the string table too... */
2330 assign_file_positions_for_relocs (abfd
)
2333 file_ptr off
= elf_tdata (abfd
)->next_file_pos
;
2335 Elf_Internal_Shdr
**shdrpp
= elf_elfsections (abfd
);
2336 Elf_Internal_Shdr
*shdrp
;
2337 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2340 if (shdrp
->sh_type
!= SHT_REL
&& shdrp
->sh_type
!= SHT_RELA
)
2342 off
= align_file_position (off
);
2343 off
= assign_file_position_for_section (shdrp
, off
);
2345 elf_tdata (abfd
)->next_file_pos
= off
;
2349 NAME(bfd_elf
,write_object_contents
) (abfd
)
2352 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2353 Elf_Internal_Ehdr
*i_ehdrp
;
2354 Elf_Internal_Shdr
**i_shdrp
;
2357 /* We don't know how to write dynamic objects. Specifically, we
2358 don't know how to construct the program header. */
2359 if ((abfd
->flags
& DYNAMIC
) != 0)
2361 fprintf (stderr
, "Writing ELF dynamic objects is not supported\n");
2362 bfd_set_error (bfd_error_wrong_format
);
2366 if (abfd
->output_has_begun
== false)
2368 if (prep_headers (abfd
) == false)
2370 if (elf_compute_section_file_positions (abfd
) == false)
2372 abfd
->output_has_begun
= true;
2375 i_shdrp
= elf_elfsections (abfd
);
2376 i_ehdrp
= elf_elfheader (abfd
);
2378 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2379 assign_file_positions_for_relocs (abfd
);
2381 /* After writing the headers, we need to write the sections too... */
2382 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2384 if (bed
->elf_backend_section_processing
)
2385 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2386 if (i_shdrp
[count
]->contents
)
2388 bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
);
2389 bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
, 1,
2394 if (bed
->elf_backend_final_write_processing
)
2395 (*bed
->elf_backend_final_write_processing
) (abfd
);
2397 return write_shdrs_and_ehdr (abfd
);
2400 /* Given an index of a section, retrieve a pointer to it. Note
2401 that for our purposes, sections are indexed by {1, 2, ...} with
2402 0 being an illegal index. */
2404 /* In the original, each ELF section went into exactly one BFD
2405 section. This doesn't really make sense, so we need a real mapping.
2406 The mapping has to hide in the Elf_Internal_Shdr since asection
2407 doesn't have anything like a tdata field... */
2410 section_from_elf_index (abfd
, index
)
2414 /* @@ Is bfd_com_section really correct in all the places it could
2415 be returned from this routine? */
2417 if (index
== SHN_ABS
)
2418 return &bfd_com_section
; /* not abs? */
2419 if (index
== SHN_COMMON
)
2420 return &bfd_com_section
;
2422 if (index
> elf_elfheader (abfd
)->e_shnum
)
2426 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2428 switch (hdr
->sh_type
)
2430 /* ELF sections that map to BFD sections */
2434 bfd_section_from_shdr (abfd
, index
);
2435 return (struct sec
*) hdr
->rawdata
;
2438 return (struct sec
*) &bfd_abs_section
;
2443 /* given a section, search the header to find them... */
2445 elf_section_from_bfd_section (abfd
, asect
)
2449 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2451 Elf_Internal_Shdr
*hdr
;
2452 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2454 if (asect
== &bfd_abs_section
)
2456 if (asect
== &bfd_com_section
)
2458 if (asect
== &bfd_und_section
)
2461 for (index
= 0; index
< maxindex
; index
++)
2463 hdr
= i_shdrp
[index
];
2464 switch (hdr
->sh_type
)
2466 /* ELF sections that map to BFD sections */
2472 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2478 /* fix_up_strtabs will generate STRTAB sections with names
2480 if (!strncmp (asect
->name
, ".stab", 5)
2481 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
2485 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2493 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2495 if (bed
->elf_backend_section_from_bfd_section
)
2500 if ((*bed
->elf_backend_section_from_bfd_section
)
2501 (abfd
, hdr
, asect
, &retval
))
2511 /* given a symbol, return the bfd index for that symbol. */
2513 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2515 struct symbol_cache_entry
**asym_ptr_ptr
;
2517 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2519 flagword flags
= asym_ptr
->flags
;
2521 /* When gas creates relocations against local labels, it creates its
2522 own symbol for the section, but does put the symbol into the
2523 symbol chain, so udata is 0. When the linker is generating
2524 relocatable output, this section symbol may be for one of the
2525 input sections rather than the output section. */
2526 if (asym_ptr
->udata
== (PTR
) 0
2527 && (flags
& BSF_SECTION_SYM
)
2528 && asym_ptr
->section
)
2532 if (asym_ptr
->section
->output_section
!= NULL
)
2533 indx
= asym_ptr
->section
->output_section
->index
;
2535 indx
= asym_ptr
->section
->index
;
2536 if (elf_section_syms (abfd
)[indx
])
2537 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2540 if (asym_ptr
->udata
)
2541 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2551 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2552 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2561 elf_slurp_symbol_table (abfd
, symptrs
)
2563 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2565 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2566 long symcount
; /* Number of external ELF symbols */
2567 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2568 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2569 Elf_Internal_Sym i_sym
;
2570 Elf_External_Sym
*x_symp
= NULL
;
2572 /* this is only valid because there is only one symtab... */
2573 /* FIXME: This is incorrect, there may also be a dynamic symbol
2574 table which is a subset of the full symbol table. We either need
2575 to be prepared to read both (and merge them) or ensure that we
2576 only read the full symbol table. Currently we only get called to
2577 read the full symbol table. -fnf */
2579 /* Read each raw ELF symbol, converting from external ELF form to
2580 internal ELF form, and then using the information to create a
2581 canonical bfd symbol table entry.
2583 Note that we allocate the initial bfd canonical symbol buffer
2584 based on a one-to-one mapping of the ELF symbols to canonical
2585 symbols. We actually use all the ELF symbols, so there will be no
2586 space left over at the end. When we have all the symbols, we
2587 build the caller's pointer vector. */
2589 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2591 bfd_set_error (bfd_error_system_call
);
2595 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2598 sym
= symbase
= NULL
;
2603 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2605 bfd_set_error (bfd_error_system_call
);
2609 symbase
= ((elf_symbol_type
*)
2610 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2611 if (symbase
== (elf_symbol_type
*) NULL
)
2613 bfd_set_error (bfd_error_no_memory
);
2618 /* Temporarily allocate room for the raw ELF symbols. */
2619 x_symp
= ((Elf_External_Sym
*)
2620 malloc (symcount
* sizeof (Elf_External_Sym
)));
2623 bfd_set_error (bfd_error_no_memory
);
2627 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2628 != symcount
* sizeof (Elf_External_Sym
))
2630 bfd_set_error (bfd_error_system_call
);
2633 /* Skip first symbol, which is a null dummy. */
2634 for (i
= 1; i
< symcount
; i
++)
2636 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2637 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2638 #ifdef ELF_KEEP_EXTSYM
2639 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2641 sym
->symbol
.the_bfd
= abfd
;
2643 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2646 sym
->symbol
.value
= i_sym
.st_value
;
2648 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
2650 sym
->symbol
.section
= section_from_elf_index (abfd
,
2653 else if (i_sym
.st_shndx
== SHN_ABS
)
2655 sym
->symbol
.section
= &bfd_abs_section
;
2657 else if (i_sym
.st_shndx
== SHN_COMMON
)
2659 sym
->symbol
.section
= &bfd_com_section
;
2660 /* Elf puts the alignment into the `value' field, and
2661 the size into the `size' field. BFD wants to see the
2662 size in the value field, and doesn't care (at the
2663 moment) about the alignment. */
2664 sym
->symbol
.value
= i_sym
.st_size
;
2666 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2668 sym
->symbol
.section
= &bfd_und_section
;
2671 sym
->symbol
.section
= &bfd_abs_section
;
2673 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2675 switch (ELF_ST_BIND (i_sym
.st_info
))
2678 sym
->symbol
.flags
|= BSF_LOCAL
;
2681 sym
->symbol
.flags
|= BSF_GLOBAL
;
2684 sym
->symbol
.flags
|= BSF_WEAK
;
2688 switch (ELF_ST_TYPE (i_sym
.st_info
))
2691 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2694 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2697 sym
->symbol
.flags
|= BSF_FUNCTION
;
2701 /* Do some backend-specific processing on this symbol. */
2703 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2704 if (ebd
->elf_backend_symbol_processing
)
2705 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2712 /* Do some backend-specific processing on this symbol table. */
2714 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2715 if (ebd
->elf_backend_symbol_table_processing
)
2716 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2719 /* We rely on the zalloc to clear out the final symbol entry. */
2721 bfd_get_symcount (abfd
) = symcount
= sym
- symbase
;
2723 /* Fill in the user's symbol pointer vector if needed. */
2727 while (symcount
-- > 0)
2729 *symptrs
++ = &sym
->symbol
;
2732 *symptrs
= 0; /* Final null pointer */
2744 /* Return the number of bytes required to hold the symtab vector.
2746 Note that we base it on the count plus 1, since we will null terminate
2747 the vector allocated based on this size. However, the ELF symbol table
2748 always has a dummy entry as symbol #0, so it ends up even. */
2751 elf_get_symtab_upper_bound (abfd
)
2754 unsigned int symcount
;
2755 unsigned int symtab_size
= 0;
2757 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2758 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2759 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2765 This function return the number of bytes required to store the
2766 relocation information associated with section <<sect>>
2767 attached to bfd <<abfd>>
2771 elf_get_reloc_upper_bound (abfd
, asect
)
2775 if (asect
->flags
& SEC_RELOC
)
2777 /* either rel or rela */
2778 return elf_section_data (asect
)->rel_hdr
.sh_size
;
2785 elf_slurp_reloca_table (abfd
, asect
, symbols
)
2790 Elf_External_Rela
*native_relocs
;
2791 arelent
*reloc_cache
;
2796 if (asect
->relocation
)
2798 if (asect
->reloc_count
== 0)
2800 if (asect
->flags
& SEC_CONSTRUCTOR
)
2803 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2804 native_relocs
= (Elf_External_Rela
*)
2805 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2808 bfd_set_error (bfd_error_no_memory
);
2811 bfd_read ((PTR
) native_relocs
,
2812 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
);
2814 reloc_cache
= (arelent
*)
2815 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2819 bfd_set_error (bfd_error_no_memory
);
2823 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2825 Elf_Internal_Rela dst
;
2826 Elf_External_Rela
*src
;
2828 cache_ptr
= reloc_cache
+ idx
;
2829 src
= native_relocs
+ idx
;
2830 elf_swap_reloca_in (abfd
, src
, &dst
);
2832 #ifdef RELOC_PROCESSING
2833 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2835 if (asect
->flags
& SEC_RELOC
)
2837 /* relocatable, so the offset is off of the section */
2838 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2842 /* non-relocatable, so the offset a virtual address */
2843 cache_ptr
->address
= dst
.r_offset
;
2846 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2847 of zero points to the dummy symbol, which was not read into
2848 the symbol table SYMBOLS. */
2849 if (ELF_R_SYM (dst
.r_info
) == 0)
2850 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2855 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2857 /* Translate any ELF section symbol into a BFD section
2859 s
= *(cache_ptr
->sym_ptr_ptr
);
2860 if (s
->flags
& BSF_SECTION_SYM
)
2862 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2863 s
= *cache_ptr
->sym_ptr_ptr
;
2864 if (s
->name
== 0 || s
->name
[0] == 0)
2868 cache_ptr
->addend
= dst
.r_addend
;
2870 /* Fill in the cache_ptr->howto field from dst.r_type */
2872 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2873 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2878 asect
->relocation
= reloc_cache
;
2884 elf_debug_section (str
, num
, hdr
)
2887 Elf_Internal_Shdr
*hdr
;
2889 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
2891 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
2892 (long) hdr
->sh_name
,
2893 (long) hdr
->sh_type
,
2894 (long) hdr
->sh_flags
);
2896 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
2897 (long) hdr
->sh_addr
,
2898 (long) hdr
->sh_offset
,
2899 (long) hdr
->sh_size
);
2901 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
2902 (long) hdr
->sh_link
,
2903 (long) hdr
->sh_info
,
2904 (long) hdr
->sh_addralign
);
2905 fprintf (stderr
, "sh_entsize = %ld\n",
2906 (long) hdr
->sh_entsize
);
2907 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
2908 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
2909 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
2914 elf_debug_file (ehdrp
)
2915 Elf_Internal_Ehdr
*ehdrp
;
2917 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
2918 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
2919 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
2920 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
2921 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
2922 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
2923 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
2928 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2933 Elf_External_Rel
*native_relocs
;
2934 arelent
*reloc_cache
;
2936 Elf_Internal_Shdr
*data_hdr
;
2938 unsigned long data_max
;
2939 char buf
[4]; /* FIXME -- might be elf64 */
2943 if (asect
->relocation
)
2945 if (asect
->reloc_count
== 0)
2947 if (asect
->flags
& SEC_CONSTRUCTOR
)
2950 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2951 native_relocs
= (Elf_External_Rel
*)
2952 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
2955 bfd_set_error (bfd_error_no_memory
);
2958 bfd_read ((PTR
) native_relocs
,
2959 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
);
2961 reloc_cache
= (arelent
*)
2962 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2966 bfd_set_error (bfd_error_no_memory
);
2970 /* Get the offset of the start of the segment we are relocating to read in
2971 the implicit addend. */
2972 data_hdr
= &elf_section_data (asect
)->this_hdr
;
2973 data_off
= data_hdr
->sh_offset
;
2974 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
2977 elf_debug_section ("data section", -1, data_hdr
);
2980 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2982 #ifdef RELOC_PROCESSING
2983 Elf_Internal_Rel dst
;
2984 Elf_External_Rel
*src
;
2986 cache_ptr
= reloc_cache
+ idx
;
2987 src
= native_relocs
+ idx
;
2988 elf_swap_reloc_in (abfd
, src
, &dst
);
2990 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2992 Elf_Internal_Rel dst
;
2993 Elf_External_Rel
*src
;
2995 cache_ptr
= reloc_cache
+ idx
;
2996 src
= native_relocs
+ idx
;
2998 elf_swap_reloc_in (abfd
, src
, &dst
);
3000 if (asect
->flags
& SEC_RELOC
)
3002 /* relocatable, so the offset is off of the section */
3003 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
3007 /* non-relocatable, so the offset a virtual address */
3008 cache_ptr
->address
= dst
.r_offset
;
3011 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
3012 of zero points to the dummy symbol, which was not read into
3013 the symbol table SYMBOLS. */
3014 if (ELF_R_SYM (dst
.r_info
) == 0)
3015 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3020 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
3022 /* Translate any ELF section symbol into a BFD section
3024 s
= *(cache_ptr
->sym_ptr_ptr
);
3025 if (s
->flags
& BSF_SECTION_SYM
)
3027 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3028 s
= *cache_ptr
->sym_ptr_ptr
;
3029 if (s
->name
== 0 || s
->name
[0] == 0)
3033 BFD_ASSERT (dst
.r_offset
<= data_max
);
3034 cache_ptr
->addend
= 0;
3036 /* Fill in the cache_ptr->howto field from dst.r_type */
3038 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
3039 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
3044 asect
->relocation
= reloc_cache
;
3049 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3055 arelent
*tblptr
= section
->relocation
;
3056 unsigned int count
= 0;
3057 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
3059 /* snarfed from coffcode.h */
3061 elf_slurp_reloca_table (abfd
, section
, symbols
);
3063 elf_slurp_reloc_table (abfd
, section
, symbols
);
3065 tblptr
= section
->relocation
;
3069 for (; count
++ < section
->reloc_count
;)
3070 *relptr
++ = tblptr
++;
3073 return section
->reloc_count
;
3077 elf_get_symtab (abfd
, alocation
)
3079 asymbol
**alocation
;
3082 if (!elf_slurp_symbol_table (abfd
, alocation
))
3085 return bfd_get_symcount (abfd
);
3089 elf_make_empty_symbol (abfd
)
3092 elf_symbol_type
*newsym
;
3094 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3097 bfd_set_error (bfd_error_no_memory
);
3102 newsym
->symbol
.the_bfd
= abfd
;
3103 return &newsym
->symbol
;
3108 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3113 bfd_symbol_info (symbol
, ret
);
3117 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3121 bfd_print_symbol_type how
;
3123 FILE *file
= (FILE *) filep
;
3126 case bfd_print_symbol_name
:
3127 fprintf (file
, "%s", symbol
->name
);
3129 case bfd_print_symbol_more
:
3130 fprintf (file
, "elf ");
3131 fprintf_vma (file
, symbol
->value
);
3132 fprintf (file
, " %lx", (long) symbol
->flags
);
3134 case bfd_print_symbol_all
:
3136 CONST
char *section_name
;
3137 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3138 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3139 fprintf (file
, " %s\t%s",
3149 elf_get_lineno (ignore_abfd
, symbol
)
3153 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3160 elf_set_arch_mach (abfd
, arch
, machine
)
3162 enum bfd_architecture arch
;
3163 unsigned long machine
;
3165 /* Allow any architecture to be supported by the elf backend */
3168 case bfd_arch_unknown
: /* EM_NONE */
3169 case bfd_arch_sparc
: /* EM_SPARC */
3170 case bfd_arch_i386
: /* EM_386 */
3171 case bfd_arch_m68k
: /* EM_68K */
3172 case bfd_arch_m88k
: /* EM_88K */
3173 case bfd_arch_i860
: /* EM_860 */
3174 case bfd_arch_mips
: /* EM_MIPS (MIPS R3000) */
3175 case bfd_arch_hppa
: /* EM_HPPA (HP PA_RISC) */
3176 case bfd_arch_powerpc
: /* EM_CYGNUS_POWERPC */
3177 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3184 elf_find_nearest_line (abfd
,
3195 CONST
char **filename_ptr
;
3196 CONST
char **functionname_ptr
;
3197 unsigned int *line_ptr
;
3203 elf_sizeof_headers (abfd
, reloc
)
3207 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
3214 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3219 bfd_size_type count
;
3221 Elf_Internal_Shdr
*hdr
;
3223 if (abfd
->output_has_begun
== false) /* set by bfd.c handler? */
3225 /* do setup calculations (FIXME) */
3226 if (prep_headers (abfd
) == false)
3228 if (elf_compute_section_file_positions (abfd
) == false)
3230 abfd
->output_has_begun
= true;
3233 hdr
= &elf_section_data (section
)->this_hdr
;
3235 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3237 if (bfd_write (location
, 1, count
, abfd
) != count
)
3244 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3247 Elf_Internal_Rela
*dst
;
3249 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3255 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3258 Elf_Internal_Rel
*dst
;
3260 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3266 /* Core file support */
3268 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3269 #include <sys/procfs.h>
3271 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
3272 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
3273 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
3279 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3286 prstatus_t
*status
= (prstatus_t
*) 0;
3288 if (descsz
== sizeof (prstatus_t
))
3290 newsect
= bfd_make_section (abfd
, ".reg");
3291 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3292 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3293 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3294 newsect
->alignment_power
= 2;
3295 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3297 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3302 /* Stash a copy of the prpsinfo structure away for future use. */
3305 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3313 if (descsz
== sizeof (prpsinfo_t
))
3315 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3317 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3323 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3331 newsect
= bfd_make_section (abfd
, ".reg2");
3332 newsect
->_raw_size
= descsz
;
3333 newsect
->filepos
= filepos
;
3334 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3335 newsect
->alignment_power
= 2;
3338 #endif /* HAVE_PROCFS */
3340 /* Return a pointer to the args (including the command name) that were
3341 seen by the program that generated the core dump. Note that for
3342 some reason, a spurious space is tacked onto the end of the args
3343 in some (at least one anyway) implementations, so strip it off if
3347 elf_core_file_failing_command (abfd
)
3351 if (core_prpsinfo (abfd
))
3353 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3354 char *scan
= p
->pr_psargs
;
3359 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3363 return p
->pr_psargs
;
3369 /* Return the number of the signal that caused the core dump. Presumably,
3370 since we have a core file, we got a signal of some kind, so don't bother
3371 checking the other process status fields, just return the signal number.
3375 elf_core_file_failing_signal (abfd
)
3379 if (core_prstatus (abfd
))
3381 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3387 /* Check to see if the core file could reasonably be expected to have
3388 come for the current executable file. Note that by default we return
3389 true unless we find something that indicates that there might be a
3394 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3403 /* First, xvecs must match since both are ELF files for the same target. */
3405 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3407 bfd_set_error (bfd_error_system_call
);
3413 /* If no prpsinfo, just return true. Otherwise, grab the last component
3414 of the exec'd pathname from the prpsinfo. */
3416 if (core_prpsinfo (core_bfd
))
3418 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3425 /* Find the last component of the executable pathname. */
3427 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3433 execname
= (char *) exec_bfd
->filename
;
3436 /* See if they match */
3438 return strcmp (execname
, corename
) ? false : true;
3444 #endif /* HAVE_PROCFS */
3447 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3448 the information that would normally be available from the /proc interface
3449 for the process, at the time the process dumped core. Currently this
3450 includes copies of the prstatus, prpsinfo, and fpregset structures.
3452 Since these structures are potentially machine dependent in size and
3453 ordering, bfd provides two levels of support for them. The first level,
3454 available on all machines since it does not require that the host
3455 have /proc support or the relevant include files, is to create a bfd
3456 section for each of the prstatus, prpsinfo, and fpregset structures,
3457 without any interpretation of their contents. With just this support,
3458 the bfd client will have to interpret the structures itself. Even with
3459 /proc support, it might want these full structures for it's own reasons.
3461 In the second level of support, where HAVE_PROCFS is defined, bfd will
3462 pick apart the structures to gather some additional information that
3463 clients may want, such as the general register set, the name of the
3464 exec'ed file and its arguments, the signal (if any) that caused the
3470 elf_corefile_note (abfd
, hdr
)
3472 Elf_Internal_Phdr
*hdr
;
3474 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3475 Elf_Internal_Note i_note
; /* Elf note, internal form */
3476 char *buf
= NULL
; /* Entire note segment contents */
3477 char *namedata
; /* Name portion of the note */
3478 char *descdata
; /* Descriptor portion of the note */
3479 char *sectname
; /* Name to use for new section */
3480 long filepos
; /* File offset to descriptor data */
3483 if (hdr
->p_filesz
> 0
3484 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3485 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3486 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3488 x_note_p
= (Elf_External_Note
*) buf
;
3489 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3491 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3492 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3493 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3494 namedata
= x_note_p
->name
;
3495 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3496 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3497 switch (i_note
.type
)
3500 /* process descdata as prstatus info */
3501 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
3502 sectname
= ".prstatus";
3505 /* process descdata as fpregset info */
3506 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
3507 sectname
= ".fpregset";
3510 /* process descdata as prpsinfo */
3511 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
3512 sectname
= ".prpsinfo";
3515 /* Unknown descriptor, just ignore it. */
3519 if (sectname
!= NULL
)
3521 newsect
= bfd_make_section (abfd
, sectname
);
3522 newsect
->_raw_size
= i_note
.descsz
;
3523 newsect
->filepos
= filepos
;
3524 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3525 newsect
->alignment_power
= 2;
3527 x_note_p
= (Elf_External_Note
*)
3528 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3535 else if (hdr
->p_filesz
> 0)
3537 bfd_set_error (bfd_error_no_memory
);
3544 /* Core files are simply standard ELF formatted files that partition
3545 the file using the execution view of the file (program header table)
3546 rather than the linking view. In fact, there is no section header
3547 table in a core file.
3549 The process status information (including the contents of the general
3550 register set) and the floating point register set are stored in a
3551 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3552 that allow standard bfd access to the general registers (.reg) and the
3553 floating point registers (.reg2).
3558 elf_core_file_p (abfd
)
3561 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3562 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3563 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3564 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3565 unsigned int phindex
;
3566 struct elf_backend_data
*ebd
;
3568 /* Read in the ELF header in external format. */
3570 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3572 bfd_set_error (bfd_error_system_call
);
3576 /* Now check to see if we have a valid ELF file, and one that BFD can
3577 make use of. The magic number must match, the address size ('class')
3578 and byte-swapping must match our XVEC entry, and it must have a
3579 program header table (FIXME: See comments re segments at top of this
3582 if (elf_file_p (&x_ehdr
) == false)
3585 bfd_set_error (bfd_error_wrong_format
);
3589 /* FIXME, Check EI_VERSION here ! */
3593 int desired_address_size
= ELFCLASS32
;
3596 int desired_address_size
= ELFCLASS64
;
3599 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3603 /* Switch xvec to match the specified byte order. */
3604 switch (x_ehdr
.e_ident
[EI_DATA
])
3606 case ELFDATA2MSB
: /* Big-endian */
3607 if (abfd
->xvec
->byteorder_big_p
== false)
3610 case ELFDATA2LSB
: /* Little-endian */
3611 if (abfd
->xvec
->byteorder_big_p
== true)
3614 case ELFDATANONE
: /* No data encoding specified */
3615 default: /* Unknown data encoding specified */
3619 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3620 the tdata pointer in the bfd. */
3623 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3624 if (elf_tdata (abfd
) == NULL
)
3626 bfd_set_error (bfd_error_no_memory
);
3630 /* FIXME, `wrong' returns from this point onward, leak memory. */
3632 /* Now that we know the byte order, swap in the rest of the header */
3633 i_ehdrp
= elf_elfheader (abfd
);
3634 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3636 elf_debug_file (i_ehdrp
);
3639 ebd
= get_elf_backend_data (abfd
);
3641 /* Check that the ELF e_machine field matches what this particular
3642 BFD format expects. */
3643 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3645 bfd_target
**target_ptr
;
3647 if (ebd
->elf_machine_code
!= EM_NONE
)
3650 /* This is the generic ELF target. Let it match any ELF target
3651 for which we do not have a specific backend. */
3652 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3654 struct elf_backend_data
*back
;
3656 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3658 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3659 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3661 /* target_ptr is an ELF backend which matches this
3662 object file, so reject the generic ELF target. */
3668 /* If there is no program header, or the type is not a core file, then
3670 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3673 /* Allocate space for a copy of the program header table in
3674 internal form, seek to the program header table in the file,
3675 read it in, and convert it to internal form. As a simple sanity
3676 check, verify that the what BFD thinks is the size of each program
3677 header table entry actually matches the size recorded in the file. */
3679 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3681 i_phdrp
= (Elf_Internal_Phdr
*)
3682 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3685 bfd_set_error (bfd_error_no_memory
);
3688 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3690 bfd_set_error (bfd_error_system_call
);
3693 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3695 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3698 bfd_set_error (bfd_error_system_call
);
3701 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3704 /* Once all of the program headers have been read and converted, we
3705 can start processing them. */
3707 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3709 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3710 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3712 elf_corefile_note (abfd
, i_phdrp
+ phindex
);
3716 /* Remember the entry point specified in the ELF file header. */
3718 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;