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
))
857 if (bfd_get_error () != bfd_error_system_call
)
858 goto got_wrong_format_error
;
863 /* Now check to see if we have a valid ELF file, and one that BFD can
864 make use of. The magic number must match, the address size ('class')
865 and byte-swapping must match our XVEC entry, and it must have a
866 section header table (FIXME: See comments re sections at top of this
869 if ((elf_file_p (&x_ehdr
) == false) ||
870 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
871 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
872 goto got_wrong_format_error
;
874 /* Check that file's byte order matches xvec's */
875 switch (x_ehdr
.e_ident
[EI_DATA
])
877 case ELFDATA2MSB
: /* Big-endian */
878 if (!abfd
->xvec
->header_byteorder_big_p
)
879 goto got_wrong_format_error
;
881 case ELFDATA2LSB
: /* Little-endian */
882 if (abfd
->xvec
->header_byteorder_big_p
)
883 goto got_wrong_format_error
;
885 case ELFDATANONE
: /* No data encoding specified */
886 default: /* Unknown data encoding specified */
887 goto got_wrong_format_error
;
890 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
891 the tdata pointer in the bfd. FIXME: memory leak, see above. */
894 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
895 if (elf_tdata (abfd
) == NULL
)
896 goto got_no_memory_error
;
898 /* Now that we know the byte order, swap in the rest of the header */
899 i_ehdrp
= elf_elfheader (abfd
);
900 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
902 elf_debug_file (i_ehdrp
);
905 /* If there is no section header table, we're hosed. */
906 if (i_ehdrp
->e_shoff
== 0)
907 goto got_wrong_format_error
;
909 /* As a simple sanity check, verify that the what BFD thinks is the
910 size of each section header table entry actually matches the size
911 recorded in the file. */
912 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
913 goto got_wrong_format_error
;
915 ebd
= get_elf_backend_data (abfd
);
917 /* Check that the ELF e_machine field matches what this particular
918 BFD format expects. */
919 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
921 bfd_target
**target_ptr
;
923 if (ebd
->elf_machine_code
!= EM_NONE
)
924 goto got_wrong_format_error
;
926 /* This is the generic ELF target. Let it match any ELF target
927 for which we do not have a specific backend. */
928 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
930 struct elf_backend_data
*back
;
932 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
934 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
935 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
937 /* target_ptr is an ELF backend which matches this
938 object file, so reject the generic ELF target. */
939 goto got_wrong_format_error
;
945 /* Set the flags and architecture before calling the backend so that
946 it can override them. */
947 if (i_ehdrp
->e_type
== ET_EXEC
)
948 abfd
->flags
|= EXEC_P
;
949 else if (i_ehdrp
->e_type
== ET_DYN
)
950 abfd
->flags
|= DYNAMIC
;
952 bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0);
954 /* Remember the entry point specified in the ELF file header. */
955 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
957 /* Let the backend double check the format and override global
959 if (ebd
->elf_backend_object_p
)
961 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
962 goto got_wrong_format_error
;
965 /* Allocate space for a copy of the section header table in
966 internal form, seek to the section header table in the file,
967 read it in, and convert it to internal form. */
968 i_shdrp
= (Elf_Internal_Shdr
*)
969 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
);
970 elf_elfsections (abfd
) =
971 (Elf_Internal_Shdr
**) bfd_alloc (abfd
, sizeof (i_shdrp
) * i_ehdrp
->e_shnum
);
972 if (!i_shdrp
|| !elf_elfsections (abfd
))
973 goto got_no_memory_error
;
974 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) == -1)
976 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
978 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
980 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
981 elf_elfsections (abfd
)[shindex
] = i_shdrp
+ shindex
;
983 /* If this is a .dynamic section, mark the object file as being
984 dynamically linked. */
985 if (i_shdrp
[shindex
].sh_type
== SHT_DYNAMIC
)
986 abfd
->flags
|= DYNAMIC
;
988 if (i_ehdrp
->e_shstrndx
)
990 bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
);
993 /* Read in the string table containing the names of the sections. We
994 will need the base pointer to this table later. */
995 /* We read this inline now, so that we don't have to go through
996 bfd_section_from_shdr with it (since this particular strtab is
997 used to find all of the ELF section names.) */
999 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
1001 goto got_wrong_format_error
;
1003 /* Once all of the section headers have been read and converted, we
1004 can start processing them. Note that the first section header is
1005 a dummy placeholder entry, so we ignore it.
1007 We also watch for the symbol table section and remember the file
1008 offset and section size for both the symbol table section and the
1009 associated string table section. */
1011 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1013 bfd_section_from_shdr (abfd
, shindex
);
1016 return (abfd
->xvec
);
1018 /* If we are going to use goto's to avoid duplicating error setting
1019 and return(NULL) code, then this at least makes it more maintainable. */
1021 got_wrong_format_error
:
1022 bfd_set_error (bfd_error_wrong_format
);
1024 got_no_memory_error
:
1025 bfd_set_error (bfd_error_no_memory
);
1028 elf_tdata (abfd
) = preserved_tdata
;
1033 /* ELF .o/exec file writing */
1035 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1036 of the symbol if there is one. */
1037 static INLINE elf_symbol_type
*
1038 elf_symbol_from (ignore_abfd
, symbol
)
1042 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1045 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1048 return (elf_symbol_type
*) symbol
;
1051 /* Create ELF output from BFD sections.
1053 Essentially, just create the section header and forget about the program
1057 elf_make_sections (abfd
, asect
, obj
)
1062 /* most of what is in bfd_shdr_from_section goes in here... */
1063 /* and all of these sections generate at *least* one ELF section. */
1064 Elf_Internal_Shdr
*this_hdr
;
1065 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1067 this_hdr
->sh_addr
= asect
->vma
;
1068 this_hdr
->sh_size
= asect
->_raw_size
;
1069 /* contents already set by elf_set_section_contents */
1071 if (asect
->flags
& SEC_RELOC
)
1073 /* emit a reloc section, and thus strtab and symtab... */
1074 Elf_Internal_Shdr
*rela_hdr
;
1075 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1077 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1079 /* orelocation has the data, reloc_count has the count... */
1082 rela_hdr
->sh_type
= SHT_RELA
;
1083 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1086 /* REL relocations */
1088 rela_hdr
->sh_type
= SHT_REL
;
1089 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1091 rela_hdr
->sh_flags
= 0;
1092 rela_hdr
->sh_addr
= 0;
1093 rela_hdr
->sh_offset
= 0;
1095 /* FIXME: Systems I've checked use an alignment of 4, but it is
1096 possible that some systems use a different alignment. */
1097 rela_hdr
->sh_addralign
= 4;
1101 if (asect
->flags
& SEC_ALLOC
)
1103 this_hdr
->sh_flags
|= SHF_ALLOC
;
1104 if (asect
->flags
& SEC_LOAD
)
1106 /* @@ Do something with sh_type? */
1111 /* If this section is not part of the program image during
1112 execution, leave the address fields at 0. */
1113 this_hdr
->sh_addr
= 0;
1116 if (!(asect
->flags
& SEC_READONLY
))
1117 this_hdr
->sh_flags
|= SHF_WRITE
;
1119 if (asect
->flags
& SEC_CODE
)
1120 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1124 write_relocs (abfd
, sec
, xxx
)
1129 Elf_Internal_Shdr
*rela_hdr
;
1130 Elf_External_Rela
*outbound_relocas
;
1131 Elf_External_Rel
*outbound_relocs
;
1133 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1134 asymbol
*last_sym
= 0;
1135 int last_sym_idx
= 9999999; /* should always be written before use */
1137 if ((sec
->flags
& SEC_RELOC
) == 0)
1139 /* Flags are sometimes inconsistent. */
1140 if (sec
->reloc_count
== 0)
1143 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1145 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1146 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1147 if (!rela_hdr
->contents
)
1149 bfd_set_error (bfd_error_no_memory
);
1150 abort (); /* FIXME */
1153 /* orelocation has the data, reloc_count has the count... */
1156 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1158 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1160 Elf_Internal_Rela dst_rela
;
1161 Elf_External_Rela
*src_rela
;
1166 ptr
= sec
->orelocation
[idx
];
1167 src_rela
= outbound_relocas
+ idx
;
1168 if (!(abfd
->flags
& EXEC_P
))
1169 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1171 dst_rela
.r_offset
= ptr
->address
;
1173 sym
= *ptr
->sym_ptr_ptr
;
1175 /* If SYM is a section symbol for an input section, which
1176 has been combined with other similar input sections (ld -r),
1177 then adjust the addend by the output_offset of sym->section.
1179 Apparently elf_symbol_from_bfd_symbol doesn't provide a 1:1
1180 mapping from bfd symbol to elf symbols in this case. */
1181 if ((sym
->flags
& BSF_SECTION_SYM
)
1183 ptr
->addend
+= sym
->section
->output_offset
;
1185 if (sym
== last_sym
)
1190 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1192 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1194 dst_rela
.r_addend
= ptr
->addend
;
1195 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1199 /* REL relocations */
1201 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1203 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1205 Elf_Internal_Rel dst_rel
;
1206 Elf_External_Rel
*src_rel
;
1211 ptr
= sec
->orelocation
[idx
];
1212 sym
= *ptr
->sym_ptr_ptr
;
1213 src_rel
= outbound_relocs
+ idx
;
1214 if (!(abfd
->flags
& EXEC_P
))
1215 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1217 dst_rel
.r_offset
= ptr
->address
;
1219 if (sym
== last_sym
)
1224 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1226 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1228 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1234 fix_up_strtabs (abfd
, asect
, obj
)
1239 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (asect
)->this_hdr
;
1240 int this_idx
= elf_section_data (asect
)->this_idx
;
1242 /* @@ Check flags! */
1243 if (!strncmp (asect
->name
, ".stab", 5)
1244 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
1246 size_t len
= strlen (asect
->name
) + 1;
1247 char *s
= (char *) malloc (len
);
1249 /* FIXME: Should deal more gracefully with errors. */
1251 strcpy (s
, asect
->name
);
1253 asect
= bfd_get_section_by_name (abfd
, s
);
1257 elf_section_data (asect
)->this_hdr
.sh_link
= this_idx
;
1258 /* @@ Assuming 32 bits! */
1259 elf_section_data (asect
)->this_hdr
.sh_entsize
= 0xc;
1261 this_hdr
->sh_type
= SHT_STRTAB
;
1266 elf_fake_sections (abfd
, asect
, obj
)
1271 /* most of what is in bfd_shdr_from_section goes in here... */
1272 /* and all of these sections generate at *least* one ELF section. */
1274 Elf_Internal_Shdr
*this_hdr
;
1275 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1277 bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
), asect
->name
);
1278 /* We need to log the type *now* so that elf_section_from_bfd_section
1279 can find us... have to set rawdata too. */
1280 this_hdr
->rawdata
= (void *) asect
;
1281 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1282 if ((asect
->flags
& SEC_ALLOC
) && (asect
->flags
& SEC_LOAD
))
1283 this_hdr
->sh_type
= SHT_PROGBITS
;
1284 else if ((asect
->flags
& SEC_ALLOC
) && ((asect
->flags
& SEC_LOAD
) == 0))
1286 BFD_ASSERT (strcmp (asect
->name
, ".bss") == 0
1287 || strcmp (asect
->name
, ".sbss") == 0);
1288 this_hdr
->sh_type
= SHT_NOBITS
;
1290 /* FIXME I am not sure how to detect a .note section from the flags
1291 word of an `asection'. */
1292 else if (!strcmp (asect
->name
, ".note"))
1293 this_hdr
->sh_type
= SHT_NOTE
;
1295 this_hdr
->sh_type
= SHT_PROGBITS
;
1297 this_hdr
->sh_flags
= 0;
1298 this_hdr
->sh_addr
= 0;
1299 this_hdr
->sh_size
= 0;
1300 this_hdr
->sh_entsize
= 0;
1301 this_hdr
->sh_info
= 0;
1302 this_hdr
->sh_link
= 0;
1303 this_hdr
->sh_offset
= 0;
1306 /* Now, check for processor-specific section types. */
1308 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1310 if (bed
->elf_backend_fake_sections
)
1311 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1315 /* Emit a strtab and symtab, and possibly a reloc section. */
1316 Elf_Internal_Shdr
*rela_hdr
;
1318 /* Note that only one symtab is used, so just remember it
1321 if (asect
->flags
& SEC_RELOC
)
1323 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1325 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1327 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1328 use_rela_p
? ".rela" : ".rel",
1330 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1331 rela_hdr
->sh_entsize
= (use_rela_p
1332 ? sizeof (Elf_External_Rela
)
1333 : sizeof (Elf_External_Rel
));
1335 rela_hdr
->sh_flags
= 0;
1336 rela_hdr
->sh_addr
= 0;
1337 rela_hdr
->sh_size
= 0;
1338 rela_hdr
->sh_offset
= 0;
1340 /* FIXME: Systems I've checked use an alignment of 4, but some
1341 systems may use a different alignment. */
1342 rela_hdr
->sh_addralign
= 4;
1347 if (asect
->flags
& SEC_ALLOC
)
1349 this_hdr
->sh_flags
|= SHF_ALLOC
;
1350 if (asect
->flags
& SEC_LOAD
)
1352 /* @@ Do something with sh_type? */
1355 if (!(asect
->flags
& SEC_READONLY
))
1356 this_hdr
->sh_flags
|= SHF_WRITE
;
1357 if (asect
->flags
& SEC_CODE
)
1358 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1361 /* Map symbol from it's internal number to the external number, moving
1362 all local symbols to be at the head of the list. */
1365 sym_is_global (abfd
, sym
)
1369 /* If the backend has a special mapping, use it. */
1370 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1371 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1374 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1376 if (sym
->flags
& BSF_LOCAL
)
1380 if (sym
->section
== 0)
1382 /* Is this valid? */
1387 if (sym
->section
== &bfd_und_section
)
1389 if (bfd_is_com_section (sym
->section
))
1391 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1397 elf_map_symbols (abfd
)
1400 int symcount
= bfd_get_symcount (abfd
);
1401 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1402 asymbol
**sect_syms
;
1404 int num_globals
= 0;
1405 int num_locals2
= 0;
1406 int num_globals2
= 0;
1408 int num_sections
= 0;
1409 Elf_Sym_Extra
*sym_extra
;
1414 fprintf (stderr
, "elf_map_symbols\n");
1418 /* Add local symbols for each section for which there are relocs.
1419 FIXME: How can we tell which sections have relocs at this point?
1420 Will reloc_count always be accurate? Actually, I think most ELF
1421 targets create section symbols for all sections anyhow. */
1422 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1424 if (max_index
< asect
->index
)
1425 max_index
= asect
->index
;
1429 elf_num_section_syms (abfd
) = max_index
;
1430 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1431 elf_section_syms (abfd
) = sect_syms
;
1435 bfd_set_error (bfd_error_no_memory
);
1439 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1441 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1444 bfd_set_error (bfd_error_no_memory
);
1447 sym
->the_bfd
= abfd
;
1448 sym
->name
= asect
->name
;
1449 sym
->value
= asect
->vma
;
1450 sym
->flags
= BSF_SECTION_SYM
;
1451 sym
->section
= asect
;
1452 sect_syms
[asect
->index
] = sym
;
1456 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1457 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1464 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1465 ((symcount
+ num_sections
+ 1)
1466 * sizeof (asymbol
*)));
1468 syms
= (asymbol
**) bfd_alloc (abfd
,
1469 (num_sections
+ 1) * sizeof (asymbol
*));
1472 bfd_set_error (bfd_error_no_memory
);
1476 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1478 if (sect_syms
[asect
->index
])
1479 syms
[symcount
++] = sect_syms
[asect
->index
];
1482 syms
[symcount
] = (asymbol
*) 0;
1483 bfd_set_symtab (abfd
, syms
, symcount
);
1486 elf_sym_extra (abfd
) = sym_extra
1487 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1490 bfd_set_error (bfd_error_no_memory
);
1494 /* Identify and classify all of the symbols. */
1495 for (idx
= 0; idx
< symcount
; idx
++)
1497 if (!sym_is_global (abfd
, syms
[idx
]))
1503 /* Now provide mapping information. Add +1 for skipping over the
1505 for (idx
= 0; idx
< symcount
; idx
++)
1507 syms
[idx
]->udata
= (PTR
) & sym_extra
[idx
];
1508 if (!sym_is_global (abfd
, syms
[idx
]))
1509 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1511 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1514 elf_num_locals (abfd
) = num_locals
;
1515 elf_num_globals (abfd
) = num_globals
;
1519 static boolean
assign_section_numbers ();
1520 static boolean
assign_file_positions_except_relocs ();
1523 elf_compute_section_file_positions (abfd
)
1526 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1528 if (!assign_section_numbers (abfd
))
1531 bfd_map_over_sections (abfd
, elf_make_sections
, 0);
1533 bfd_map_over_sections (abfd
, fix_up_strtabs
, 0); /* .stab/.stabstr &c */
1535 if (swap_out_syms (abfd
) == false)
1538 if (!assign_file_positions_except_relocs (abfd
))
1545 elf_write_phdrs (abfd
, i_ehdrp
, i_phdrp
, phdr_cnt
)
1547 Elf_Internal_Ehdr
*i_ehdrp
;
1548 Elf_Internal_Phdr
*i_phdrp
;
1549 unsigned short phdr_cnt
;
1551 /* first program header entry goes after the file header */
1552 int outbase
= i_ehdrp
->e_phoff
;
1554 Elf_External_Phdr x_phdr
;
1556 for (i
= 0; i
< phdr_cnt
; i
++)
1558 elf_swap_phdr_out (abfd
, i_phdrp
+ i
, &x_phdr
);
1559 if (bfd_seek (abfd
, outbase
, SEEK_SET
) != 0
1560 || (bfd_write ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
1561 != sizeof (x_phdr
)))
1563 outbase
+= sizeof (x_phdr
);
1569 static const Elf_Internal_Shdr null_shdr
;
1571 /* Assign all ELF section numbers. The dummy first section is handled here
1572 too. The link/info pointers for the standard section types are filled
1573 in here too, while we're at it. (Link pointers for .stab sections are
1574 not filled in here.) */
1576 assign_section_numbers (abfd
)
1579 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1581 int section_number
= 1;
1583 Elf_Internal_Shdr
**i_shdrp
;
1585 t
->shstrtab_hdr
.sh_size
= elf_shstrtab (abfd
)->length
;
1586 t
->shstrtab_hdr
.contents
= (void *) elf_shstrtab (abfd
)->tab
;
1587 shstrtab_length_fixed
= 1;
1589 t
->shstrtab_section
= section_number
++;
1590 elf_elfheader (abfd
)->e_shstrndx
= t
->shstrtab_section
;
1593 t
->symtab_section
= section_number
++;
1594 t
->strtab_section
= section_number
++;
1595 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1597 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1599 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1600 d
->this_idx
= section_number
++;
1601 if (sec
->flags
& SEC_RELOC
)
1603 d
->rel_idx
= section_number
++;
1604 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1605 d
->rel_hdr
.sh_info
= d
->this_idx
;
1609 /* No handling for per-section string tables currently. */
1611 elf_elfheader (abfd
)->e_shnum
= section_number
;
1613 /* Set up the list of section header pointers, in agreement with the
1615 i_shdrp
= (Elf_Internal_Shdr
**)
1616 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*));
1619 bfd_set_error (bfd_error_no_memory
);
1622 elf_elfsections (abfd
) = i_shdrp
;
1623 for (i
= 0; i
< section_number
; i
++)
1626 i_shdrp
[0] = (Elf_Internal_Shdr
*) & null_shdr
;
1627 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1630 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1631 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1633 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1635 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1636 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1638 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1640 /* Make sure we got everything.... */
1641 for (i
= 0; i
< section_number
; i
++)
1642 if (i_shdrp
[i
] == 0)
1647 static INLINE file_ptr
1648 assign_file_position_for_section (i_shdrp
, offset
)
1649 Elf_Internal_Shdr
*i_shdrp
;
1654 if (i_shdrp
->sh_addralign
!= 0)
1655 align
= i_shdrp
->sh_addralign
;
1658 i_shdrp
->sh_offset
= offset
= BFD_ALIGN (offset
, align
);
1659 if (i_shdrp
->rawdata
!= NULL
)
1660 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1661 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1662 offset
+= i_shdrp
->sh_size
;
1666 static INLINE file_ptr
1667 align_file_position (off
)
1670 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1673 static INLINE file_ptr
1674 assign_file_positions_for_symtab_and_strtabs (abfd
, off
)
1678 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1680 off
= align_file_position (off
);
1681 off
= assign_file_position_for_section (&t
->symtab_hdr
, off
);
1682 off
= assign_file_position_for_section (&t
->shstrtab_hdr
, off
);
1683 off
= assign_file_position_for_section (&t
->strtab_hdr
, off
);
1689 bfd_vma low
, mem_size
;
1693 struct seg_info
*next
;
1697 map_program_segments (abfd
)
1700 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1701 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1702 Elf_Internal_Shdr
*i_shdrp
;
1703 Elf_Internal_Phdr
*phdr
;
1705 unsigned int i
, n_left
= 0;
1706 file_ptr lowest_offset
= 0;
1707 struct seg_info
*seg
= NULL
;
1709 done
= (char *) malloc (i_ehdrp
->e_shnum
);
1710 if (done
== NULL
&& i_ehdrp
->e_shnum
!= 0)
1712 bfd_set_error (bfd_error_no_memory
);
1715 memset (done
, 0, i_ehdrp
->e_shnum
);
1716 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1718 i_shdrp
= i_shdrpp
[i
];
1719 /* If it's going to be mapped in, it's been assigned a position. */
1720 if (i_shdrp
->sh_offset
+ 1 == 0)
1722 /* Well, not really, but we won't process it here. */
1726 if (i_shdrp
->sh_offset
< lowest_offset
1727 || lowest_offset
== 0)
1728 lowest_offset
= i_shdrp
->sh_offset
;
1729 /* Only interested in PROGBITS or NOBITS for generating segments. */
1730 switch (i_shdrp
->sh_type
)
1743 bfd_vma lowest_vma
= -1, high
;
1747 struct seg_info
*snew
;
1748 struct seg_info
**s_ptr
;
1750 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1752 i_shdrp
= i_shdrpp
[i
];
1753 if (!done
[i
] && i_shdrp
->sh_addr
< lowest_vma
)
1755 lowest_vma
= i_shdrp
->sh_addr
;
1761 /* So now we know the lowest vma of any unassigned sections; start
1763 snew
= (struct seg_info
*) bfd_alloc (abfd
, sizeof (struct seg_info
));
1766 bfd_set_error (bfd_error_no_memory
);
1770 while (*s_ptr
!= (struct seg_info
*) NULL
)
1771 s_ptr
= &(*s_ptr
)->next
;
1774 snew
->low
= lowest_vma
;
1775 i_shdrp
= i_shdrpp
[low_sec
];
1776 snew
->start_pos
= i_shdrp
->sh_offset
;
1777 snew
->sh_flags
= i_shdrp
->sh_flags
;
1778 done
[low_sec
] = 1, n_left
--;
1779 mem_size
= i_shdrp
->sh_size
;
1780 high
= lowest_vma
+ i_shdrp
->sh_size
;
1782 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1783 file_size
= i_shdrp
->sh_size
;
1785 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1791 i_shdrp
= i_shdrpp
[i
];
1792 /* position of next byte on disk */
1793 f1
= snew
->start_pos
+ file_size
;
1794 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1796 if (i_shdrp
->sh_offset
- f1
!= i_shdrp
->sh_addr
- high
)
1798 if (file_size
!= mem_size
)
1802 /* sh_type == NOBITS */
1804 /* If the section in question has no contents in the disk
1805 file, we really don't care where it supposedly starts.
1806 But we don't want to bother merging it into this segment
1807 if it doesn't start on this memory page. */
1808 bfd_vma page1
, page2
;
1809 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1811 /* page number in address space of current end of snew */
1812 page1
= (high
- 1 + maxpagesize
- 1) / maxpagesize
;
1813 /* page number in address space of start of this section */
1814 page2
= (i_shdrp
->sh_addr
+ maxpagesize
- 1) / maxpagesize
;
1819 done
[i
] = 1, n_left
--;
1820 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1821 file_size
= i_shdrp
->sh_offset
+ i_shdrp
->sh_size
- snew
->start_pos
;
1822 mem_size
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
- snew
->low
;
1823 high
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
;
1826 snew
->file_size
= file_size
;
1827 snew
->mem_size
= mem_size
;
1829 /* Now do something with the list of segments we've built up. */
1831 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1836 for (s
= seg
; s
; s
= s
->next
)
1840 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1841 sz
= sizeof (Elf_External_Phdr
) * n_segs
;
1842 if (align_file_position (i_ehdrp
->e_ehsize
) + sz
<= lowest_offset
)
1843 i_ehdrp
->e_phoff
= align_file_position (i_ehdrp
->e_ehsize
);
1846 i_ehdrp
->e_phoff
= align_file_position (elf_tdata (abfd
)->next_file_pos
);
1847 elf_tdata (abfd
)->next_file_pos
= i_ehdrp
->e_phoff
+ sz
;
1849 phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
,
1850 n_segs
* sizeof (Elf_Internal_Phdr
));
1853 bfd_set_error (bfd_error_no_memory
);
1854 abort (); /* FIXME */
1856 elf_tdata (abfd
)->phdr
= phdr
;
1859 phdr
->p_type
= PT_LOAD
; /* only type we really support so far */
1860 phdr
->p_offset
= seg
->start_pos
;
1861 phdr
->p_vaddr
= seg
->low
;
1863 phdr
->p_filesz
= seg
->file_size
;
1864 phdr
->p_memsz
= seg
->mem_size
;
1865 phdr
->p_flags
= PF_R
;
1866 phdr
->p_align
= maxpagesize
; /* ? */
1867 if (seg
->sh_flags
& SHF_WRITE
)
1868 /* SysVr4 ELF docs say "data segments normally have read, write,
1869 and execute permissions." */
1870 phdr
->p_flags
|= (PF_W
| PF_X
);
1871 if (seg
->sh_flags
& SHF_EXECINSTR
)
1872 phdr
->p_flags
|= PF_X
;
1876 i_ehdrp
->e_phnum
= n_segs
;
1878 elf_write_phdrs (abfd
, i_ehdrp
, elf_tdata (abfd
)->phdr
, i_ehdrp
->e_phnum
);
1889 assign_file_positions_except_relocs (abfd
)
1892 /* For now, we ignore the possibility of having program segments, which
1893 may require some alignment in the file. That'll require padding, and
1894 some interesting calculations to optimize file space usage.
1896 Also, since the application may change the list of relocations for
1897 a given section, we don't figure them in here. We'll put them at the
1898 end of the file, at positions computed during bfd_close.
1900 The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
1901 or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
1903 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1906 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1907 Elf_Internal_Shdr
*i_shdrp
;
1908 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1909 int exec_p
= (abfd
->flags
& EXEC_P
) != 0;
1910 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1912 /* Everything starts after the ELF file header. */
1913 off
= i_ehdrp
->e_ehsize
;
1917 /* Section headers. */
1918 off
= align_file_position (off
);
1919 i_ehdrp
->e_shoff
= off
;
1920 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1921 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1923 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1925 /* The symtab and strtab sections are placed by
1926 assign_file_positions_for_symtab_and_strtabs. */
1927 if (i
== t
->symtab_section
1928 || i
== t
->strtab_section
1929 || i
== t
->shstrtab_section
)
1932 i_shdrp
= i_shdrpp
[i
];
1933 if (i_shdrp
->sh_type
== SHT_REL
|| i_shdrp
->sh_type
== SHT_RELA
)
1935 i_shdrp
->sh_offset
= -1;
1940 if (maxpagesize
== 0)
1941 maxpagesize
= 1; /* make the arithmetic work */
1942 /* This isn't necessarily going to give the best packing, if the
1943 segments require padding between them, but since that isn't
1944 usually the case, this'll do. */
1945 if ((i_shdrp
->sh_flags
& SHF_ALLOC
) == 0)
1947 i_shdrp
->sh_offset
= -1;
1950 /* Blindly assume that the segments are ordered optimally. With
1951 the default LD script, they will be. */
1952 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1954 /* need big unsigned type */
1956 addtl_off
= i_shdrp
->sh_addr
- off
;
1957 addtl_off
= addtl_off
% maxpagesize
;
1964 off
= assign_file_position_for_section (i_shdrp
, off
);
1967 && i_shdrp
->sh_type
== SHT_NOBITS
1968 && (i
== i_ehdrp
->e_shnum
1969 || i_shdrpp
[i
+ 1]->sh_type
!= SHT_NOBITS
))
1971 /* Skip to the next page to ensure that when the file is
1972 loaded the bss section is loaded with zeroes. I don't
1973 know if this is required on all platforms, but it
1974 shouldn't really hurt. */
1975 off
= BFD_ALIGN (off
, maxpagesize
);
1979 && (abfd
->flags
& D_PAGED
) != 0
1980 && get_elf_backend_data (abfd
)->maxpagesize
> 1
1981 && i_shdrp
->sh_type
== SHT_PROGBITS
1982 && (i_shdrp
->sh_flags
& SHF_ALLOC
)
1983 && (i_shdrp
->sh_offset
- i_shdrp
->sh_addr
) % get_elf_backend_data (abfd
)->maxpagesize
!= 0)
1988 elf_tdata (abfd
)->next_file_pos
= off
;
1989 if (!map_program_segments (abfd
))
1991 off
= elf_tdata (abfd
)->next_file_pos
;
1993 /* Section headers. */
1994 off
= align_file_position (off
);
1995 i_ehdrp
->e_shoff
= off
;
1996 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1998 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
2000 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
2002 i_shdrp
= i_shdrpp
[i
];
2003 if (i_shdrp
->sh_offset
+ 1 == 0
2004 && i_shdrp
->sh_type
!= SHT_REL
2005 && i_shdrp
->sh_type
!= SHT_RELA
)
2006 off
= assign_file_position_for_section (i_shdrp
, off
);
2009 elf_tdata (abfd
)->next_file_pos
= off
;
2017 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2018 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2019 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2021 struct strtab
*shstrtab
;
2023 i_ehdrp
= elf_elfheader (abfd
);
2024 i_shdrp
= elf_elfsections (abfd
);
2026 shstrtab
= bfd_new_strtab (abfd
);
2030 elf_shstrtab (abfd
) = shstrtab
;
2032 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
2033 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
2034 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
2035 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
2037 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
2038 i_ehdrp
->e_ident
[EI_DATA
] =
2039 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
2040 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
2042 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
2043 i_ehdrp
->e_ident
[count
] = 0;
2045 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
2046 switch (bfd_get_arch (abfd
))
2048 case bfd_arch_unknown
:
2049 i_ehdrp
->e_machine
= EM_NONE
;
2051 case bfd_arch_sparc
:
2052 i_ehdrp
->e_machine
= EM_SPARC
;
2053 /* start-sanitize-v9 */
2055 i_ehdrp
->e_machine
= EM_SPARC64
;
2057 /* end-sanitize-v9 */
2060 i_ehdrp
->e_machine
= EM_386
;
2063 i_ehdrp
->e_machine
= EM_68K
;
2066 i_ehdrp
->e_machine
= EM_88K
;
2069 i_ehdrp
->e_machine
= EM_860
;
2071 case bfd_arch_mips
: /* MIPS Rxxxx */
2072 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
2075 i_ehdrp
->e_machine
= EM_HPPA
;
2077 case bfd_arch_powerpc
:
2078 i_ehdrp
->e_machine
= EM_CYGNUS_POWERPC
;
2080 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
2082 i_ehdrp
->e_machine
= EM_NONE
;
2084 i_ehdrp
->e_version
= EV_CURRENT
;
2085 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2087 /* no program header, for now. */
2088 i_ehdrp
->e_phoff
= 0;
2089 i_ehdrp
->e_phentsize
= 0;
2090 i_ehdrp
->e_phnum
= 0;
2092 /* each bfd section is section header entry */
2093 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2094 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2096 /* if we're building an executable, we'll need a program header table */
2097 if (abfd
->flags
& EXEC_P
)
2099 /* it all happens later */
2101 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2103 /* elf_build_phdrs() returns a (NULL-terminated) array of
2104 Elf_Internal_Phdrs */
2105 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2106 i_ehdrp
->e_phoff
= outbase
;
2107 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2112 i_ehdrp
->e_phentsize
= 0;
2114 i_ehdrp
->e_phoff
= 0;
2117 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2119 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2121 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2127 swap_out_syms (abfd
)
2130 if (!elf_map_symbols (abfd
))
2133 /* Dump out the symtabs. */
2135 int symcount
= bfd_get_symcount (abfd
);
2136 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2137 struct strtab
*stt
= bfd_new_strtab (abfd
);
2138 Elf_Internal_Shdr
*symtab_hdr
;
2139 Elf_Internal_Shdr
*symstrtab_hdr
;
2140 Elf_External_Sym
*outbound_syms
;
2145 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2146 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2147 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2148 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2149 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2151 /* FIXME: Systems I've checked use 4 byte alignment for .symtab,
2152 but it is possible that there are systems which use a different
2154 symtab_hdr
->sh_addralign
= 4;
2156 /* see assert in elf_fake_sections that supports this: */
2157 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2158 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2160 outbound_syms
= (Elf_External_Sym
*)
2161 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2164 bfd_set_error (bfd_error_no_memory
);
2167 /* now generate the data (for "contents") */
2169 /* Fill in zeroth symbol and swap it out. */
2170 Elf_Internal_Sym sym
;
2176 sym
.st_shndx
= SHN_UNDEF
;
2177 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2179 for (idx
= 0; idx
< symcount
; idx
++)
2181 Elf_Internal_Sym sym
;
2182 bfd_vma value
= syms
[idx
]->value
;
2184 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2185 /* Section symbols have no names. */
2188 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2190 if (bfd_is_com_section (syms
[idx
]->section
))
2192 /* ELF common symbols put the alignment into the `value' field,
2193 and the size into the `size' field. This is backwards from
2194 how BFD handles it, so reverse it here. */
2195 sym
.st_size
= value
;
2196 /* Should retrieve this from somewhere... */
2198 sym
.st_shndx
= elf_section_from_bfd_section (abfd
,
2199 syms
[idx
]->section
);
2203 asection
*sec
= syms
[idx
]->section
;
2204 elf_symbol_type
*type_ptr
;
2207 if (sec
->output_section
)
2209 value
+= sec
->output_offset
;
2210 sec
= sec
->output_section
;
2213 sym
.st_value
= value
;
2214 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2215 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2216 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2220 /* Writing this would be a hell of a lot easier if we had
2221 some decent documentation on bfd, and knew what to expect
2222 of the library, and what to demand of applications. For
2223 example, it appears that `objcopy' might not set the
2224 section of a symbol to be a section that is actually in
2226 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2227 BFD_ASSERT (sec2
!= 0);
2228 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2229 BFD_ASSERT (shndx
!= -1);
2233 if (bfd_is_com_section (syms
[idx
]->section
))
2234 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2235 else if (syms
[idx
]->section
== &bfd_und_section
)
2236 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2237 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2238 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2239 else if (syms
[idx
]->flags
& BSF_FILE
)
2240 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2243 int bind
= STB_LOCAL
;
2244 int type
= STT_OBJECT
;
2245 unsigned int flags
= syms
[idx
]->flags
;
2247 if (flags
& BSF_LOCAL
)
2249 else if (flags
& BSF_WEAK
)
2251 else if (flags
& BSF_GLOBAL
)
2254 if (flags
& BSF_FUNCTION
)
2257 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2261 elf_swap_symbol_out (abfd
, &sym
,
2263 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2266 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2267 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2268 symstrtab_hdr
->sh_size
= stt
->length
;
2269 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2271 symstrtab_hdr
->sh_flags
= 0;
2272 symstrtab_hdr
->sh_addr
= 0;
2273 symstrtab_hdr
->sh_entsize
= 0;
2274 symstrtab_hdr
->sh_link
= 0;
2275 symstrtab_hdr
->sh_info
= 0;
2276 symstrtab_hdr
->sh_addralign
= 1;
2277 symstrtab_hdr
->size
= 0;
2280 /* put the strtab out too... */
2282 Elf_Internal_Shdr
*this_hdr
;
2284 this_hdr
= &elf_tdata (abfd
)->shstrtab_hdr
;
2285 this_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
2286 this_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
2287 this_hdr
->sh_type
= SHT_STRTAB
;
2288 this_hdr
->sh_flags
= 0;
2289 this_hdr
->sh_addr
= 0;
2290 this_hdr
->sh_entsize
= 0;
2291 this_hdr
->sh_addralign
= 1;
2298 write_shdrs_and_ehdr (abfd
)
2301 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2302 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2303 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2304 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2306 struct strtab
*shstrtab
;
2308 i_ehdrp
= elf_elfheader (abfd
);
2309 i_shdrp
= elf_elfsections (abfd
);
2310 shstrtab
= elf_shstrtab (abfd
);
2312 /* swap the header before spitting it out... */
2315 elf_debug_file (i_ehdrp
);
2317 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2318 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0
2319 || (bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
)
2320 != sizeof (x_ehdr
)))
2323 /* at this point we've concocted all the ELF sections... */
2324 x_shdrp
= (Elf_External_Shdr
*)
2325 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2328 bfd_set_error (bfd_error_no_memory
);
2332 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2335 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2338 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2340 if (bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
) != 0
2341 || (bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
)
2342 != sizeof (*x_shdrp
) * i_ehdrp
->e_shnum
))
2345 /* need to dump the string table too... */
2351 assign_file_positions_for_relocs (abfd
)
2354 file_ptr off
= elf_tdata (abfd
)->next_file_pos
;
2356 Elf_Internal_Shdr
**shdrpp
= elf_elfsections (abfd
);
2357 Elf_Internal_Shdr
*shdrp
;
2358 for (i
= 1; i
< elf_elfheader (abfd
)->e_shnum
; i
++)
2361 if (shdrp
->sh_type
!= SHT_REL
&& shdrp
->sh_type
!= SHT_RELA
)
2363 off
= align_file_position (off
);
2364 off
= assign_file_position_for_section (shdrp
, off
);
2366 elf_tdata (abfd
)->next_file_pos
= off
;
2370 NAME(bfd_elf
,write_object_contents
) (abfd
)
2373 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2374 Elf_Internal_Ehdr
*i_ehdrp
;
2375 Elf_Internal_Shdr
**i_shdrp
;
2378 /* We don't know how to write dynamic objects. Specifically, we
2379 don't know how to construct the program header. */
2380 if ((abfd
->flags
& DYNAMIC
) != 0)
2382 fprintf (stderr
, "Writing ELF dynamic objects is not supported\n");
2383 bfd_set_error (bfd_error_wrong_format
);
2387 if (abfd
->output_has_begun
== false)
2389 /* Do any elf backend specific processing first. */
2390 if (bed
->elf_backend_begin_write_processing
)
2391 (*bed
->elf_backend_begin_write_processing
) (abfd
);
2393 if (prep_headers (abfd
) == false)
2395 if (elf_compute_section_file_positions (abfd
) == false)
2397 abfd
->output_has_begun
= true;
2400 i_shdrp
= elf_elfsections (abfd
);
2401 i_ehdrp
= elf_elfheader (abfd
);
2403 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2404 assign_file_positions_for_relocs (abfd
);
2406 /* After writing the headers, we need to write the sections too... */
2407 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2409 if (bed
->elf_backend_section_processing
)
2410 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2411 if (i_shdrp
[count
]->contents
)
2413 if (bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
) != 0
2414 || (bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
,
2416 != i_shdrp
[count
]->sh_size
))
2421 if (bed
->elf_backend_final_write_processing
)
2422 (*bed
->elf_backend_final_write_processing
) (abfd
);
2424 return write_shdrs_and_ehdr (abfd
);
2427 /* Given an index of a section, retrieve a pointer to it. Note
2428 that for our purposes, sections are indexed by {1, 2, ...} with
2429 0 being an illegal index. */
2431 /* In the original, each ELF section went into exactly one BFD
2432 section. This doesn't really make sense, so we need a real mapping.
2433 The mapping has to hide in the Elf_Internal_Shdr since asection
2434 doesn't have anything like a tdata field... */
2437 section_from_elf_index (abfd
, index
)
2441 /* @@ Is bfd_com_section really correct in all the places it could
2442 be returned from this routine? */
2444 if (index
== SHN_ABS
)
2445 return &bfd_com_section
; /* not abs? */
2446 if (index
== SHN_COMMON
)
2447 return &bfd_com_section
;
2449 if (index
> elf_elfheader (abfd
)->e_shnum
)
2453 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2455 switch (hdr
->sh_type
)
2457 /* ELF sections that map to BFD sections */
2461 bfd_section_from_shdr (abfd
, index
);
2462 return (struct sec
*) hdr
->rawdata
;
2465 return (struct sec
*) &bfd_abs_section
;
2470 /* given a section, search the header to find them... */
2472 elf_section_from_bfd_section (abfd
, asect
)
2476 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2478 Elf_Internal_Shdr
*hdr
;
2479 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2481 if (asect
== &bfd_abs_section
)
2483 if (asect
== &bfd_com_section
)
2485 if (asect
== &bfd_und_section
)
2488 for (index
= 0; index
< maxindex
; index
++)
2490 hdr
= i_shdrp
[index
];
2491 switch (hdr
->sh_type
)
2493 /* ELF sections that map to BFD sections */
2499 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2505 /* fix_up_strtabs will generate STRTAB sections with names
2507 if (!strncmp (asect
->name
, ".stab", 5)
2508 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
2512 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2520 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2522 if (bed
->elf_backend_section_from_bfd_section
)
2527 if ((*bed
->elf_backend_section_from_bfd_section
)
2528 (abfd
, hdr
, asect
, &retval
))
2538 /* given a symbol, return the bfd index for that symbol. */
2540 elf_symbol_from_bfd_symbol (abfd
, asym_ptr_ptr
)
2542 struct symbol_cache_entry
**asym_ptr_ptr
;
2544 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2546 flagword flags
= asym_ptr
->flags
;
2548 /* When gas creates relocations against local labels, it creates its
2549 own symbol for the section, but does put the symbol into the
2550 symbol chain, so udata is 0. When the linker is generating
2551 relocatable output, this section symbol may be for one of the
2552 input sections rather than the output section. */
2553 if (asym_ptr
->udata
== (PTR
) 0
2554 && (flags
& BSF_SECTION_SYM
)
2555 && asym_ptr
->section
)
2559 if (asym_ptr
->section
->output_section
!= NULL
)
2560 indx
= asym_ptr
->section
->output_section
->index
;
2562 indx
= asym_ptr
->section
->index
;
2563 if (elf_section_syms (abfd
)[indx
])
2564 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2567 if (asym_ptr
->udata
)
2568 idx
= ((Elf_Sym_Extra
*) asym_ptr
->udata
)->elf_sym_num
;
2578 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2579 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2588 elf_slurp_symbol_table (abfd
, symptrs
)
2590 asymbol
**symptrs
; /* Buffer for generated bfd symbols */
2592 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2593 long symcount
; /* Number of external ELF symbols */
2594 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2595 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2596 Elf_Internal_Sym i_sym
;
2597 Elf_External_Sym
*x_symp
= NULL
;
2599 /* this is only valid because there is only one symtab... */
2600 /* FIXME: This is incorrect, there may also be a dynamic symbol
2601 table which is a subset of the full symbol table. We either need
2602 to be prepared to read both (and merge them) or ensure that we
2603 only read the full symbol table. Currently we only get called to
2604 read the full symbol table. -fnf */
2606 /* Read each raw ELF symbol, converting from external ELF form to
2607 internal ELF form, and then using the information to create a
2608 canonical bfd symbol table entry.
2610 Note that we allocate the initial bfd canonical symbol buffer
2611 based on a one-to-one mapping of the ELF symbols to canonical
2612 symbols. We actually use all the ELF symbols, so there will be no
2613 space left over at the end. When we have all the symbols, we
2614 build the caller's pointer vector. */
2616 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2619 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2622 sym
= symbase
= NULL
;
2627 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2630 symbase
= ((elf_symbol_type
*)
2631 bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
)));
2632 if (symbase
== (elf_symbol_type
*) NULL
)
2634 bfd_set_error (bfd_error_no_memory
);
2639 /* Temporarily allocate room for the raw ELF symbols. */
2640 x_symp
= ((Elf_External_Sym
*)
2641 malloc (symcount
* sizeof (Elf_External_Sym
)));
2642 if (x_symp
== NULL
&& symcount
!= 0)
2644 bfd_set_error (bfd_error_no_memory
);
2648 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2649 != symcount
* sizeof (Elf_External_Sym
))
2651 /* Skip first symbol, which is a null dummy. */
2652 for (i
= 1; i
< symcount
; i
++)
2654 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2655 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2656 #ifdef ELF_KEEP_EXTSYM
2657 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2659 sym
->symbol
.the_bfd
= abfd
;
2661 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2664 sym
->symbol
.value
= i_sym
.st_value
;
2666 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
2668 sym
->symbol
.section
= section_from_elf_index (abfd
,
2671 else if (i_sym
.st_shndx
== SHN_ABS
)
2673 sym
->symbol
.section
= &bfd_abs_section
;
2675 else if (i_sym
.st_shndx
== SHN_COMMON
)
2677 sym
->symbol
.section
= &bfd_com_section
;
2678 /* Elf puts the alignment into the `value' field, and
2679 the size into the `size' field. BFD wants to see the
2680 size in the value field, and doesn't care (at the
2681 moment) about the alignment. */
2682 sym
->symbol
.value
= i_sym
.st_size
;
2684 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2686 sym
->symbol
.section
= &bfd_und_section
;
2689 sym
->symbol
.section
= &bfd_abs_section
;
2691 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2693 switch (ELF_ST_BIND (i_sym
.st_info
))
2696 sym
->symbol
.flags
|= BSF_LOCAL
;
2699 sym
->symbol
.flags
|= BSF_GLOBAL
;
2702 sym
->symbol
.flags
|= BSF_WEAK
;
2706 switch (ELF_ST_TYPE (i_sym
.st_info
))
2709 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2712 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2715 sym
->symbol
.flags
|= BSF_FUNCTION
;
2719 /* Do some backend-specific processing on this symbol. */
2721 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2722 if (ebd
->elf_backend_symbol_processing
)
2723 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2730 /* Do some backend-specific processing on this symbol table. */
2732 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2733 if (ebd
->elf_backend_symbol_table_processing
)
2734 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2737 /* We rely on the zalloc to clear out the final symbol entry. */
2739 bfd_get_symcount (abfd
) = symcount
= sym
- symbase
;
2741 /* Fill in the user's symbol pointer vector if needed. */
2745 while (symcount
-- > 0)
2747 *symptrs
++ = &sym
->symbol
;
2750 *symptrs
= 0; /* Final null pointer */
2762 /* Return the number of bytes required to hold the symtab vector.
2764 Note that we base it on the count plus 1, since we will null terminate
2765 the vector allocated based on this size. However, the ELF symbol table
2766 always has a dummy entry as symbol #0, so it ends up even. */
2769 elf_get_symtab_upper_bound (abfd
)
2774 Elf_Internal_Shdr
*hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2776 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2777 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
*));
2783 This function return the number of bytes required to store the
2784 relocation information associated with section <<sect>>
2785 attached to bfd <<abfd>>
2789 elf_get_reloc_upper_bound (abfd
, asect
)
2793 if (asect
->flags
& SEC_RELOC
)
2795 /* either rel or rela */
2796 return elf_section_data (asect
)->rel_hdr
.sh_size
;
2803 elf_slurp_reloca_table (abfd
, asect
, symbols
)
2808 Elf_External_Rela
*native_relocs
;
2809 arelent
*reloc_cache
;
2814 if (asect
->relocation
)
2816 if (asect
->reloc_count
== 0)
2818 if (asect
->flags
& SEC_CONSTRUCTOR
)
2821 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2823 native_relocs
= (Elf_External_Rela
*)
2824 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2827 bfd_set_error (bfd_error_no_memory
);
2830 if (bfd_read ((PTR
) native_relocs
,
2831 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
)
2832 != sizeof (Elf_External_Rela
) * asect
->reloc_count
)
2835 reloc_cache
= (arelent
*)
2836 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2840 bfd_set_error (bfd_error_no_memory
);
2844 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2846 Elf_Internal_Rela dst
;
2847 Elf_External_Rela
*src
;
2849 cache_ptr
= reloc_cache
+ idx
;
2850 src
= native_relocs
+ idx
;
2851 elf_swap_reloca_in (abfd
, src
, &dst
);
2853 #ifdef RELOC_PROCESSING
2854 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2856 if (asect
->flags
& SEC_RELOC
)
2858 /* relocatable, so the offset is off of the section */
2859 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2863 /* non-relocatable, so the offset a virtual address */
2864 cache_ptr
->address
= dst
.r_offset
;
2867 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2868 of zero points to the dummy symbol, which was not read into
2869 the symbol table SYMBOLS. */
2870 if (ELF_R_SYM (dst
.r_info
) == 0)
2871 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2876 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2878 /* Translate any ELF section symbol into a BFD section
2880 s
= *(cache_ptr
->sym_ptr_ptr
);
2881 if (s
->flags
& BSF_SECTION_SYM
)
2883 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2884 s
= *cache_ptr
->sym_ptr_ptr
;
2885 if (s
->name
== 0 || s
->name
[0] == 0)
2889 cache_ptr
->addend
= dst
.r_addend
;
2891 /* Fill in the cache_ptr->howto field from dst.r_type */
2893 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2894 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2899 asect
->relocation
= reloc_cache
;
2905 elf_debug_section (str
, num
, hdr
)
2908 Elf_Internal_Shdr
*hdr
;
2910 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
2912 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
2913 (long) hdr
->sh_name
,
2914 (long) hdr
->sh_type
,
2915 (long) hdr
->sh_flags
);
2917 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
2918 (long) hdr
->sh_addr
,
2919 (long) hdr
->sh_offset
,
2920 (long) hdr
->sh_size
);
2922 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
2923 (long) hdr
->sh_link
,
2924 (long) hdr
->sh_info
,
2925 (long) hdr
->sh_addralign
);
2926 fprintf (stderr
, "sh_entsize = %ld\n",
2927 (long) hdr
->sh_entsize
);
2928 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
2929 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
2930 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
2935 elf_debug_file (ehdrp
)
2936 Elf_Internal_Ehdr
*ehdrp
;
2938 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
2939 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
2940 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
2941 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
2942 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
2943 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
2944 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
2949 elf_slurp_reloc_table (abfd
, asect
, symbols
)
2954 Elf_External_Rel
*native_relocs
;
2955 arelent
*reloc_cache
;
2957 Elf_Internal_Shdr
*data_hdr
;
2959 unsigned long data_max
;
2960 char buf
[4]; /* FIXME -- might be elf64 */
2964 if (asect
->relocation
)
2966 if (asect
->reloc_count
== 0)
2968 if (asect
->flags
& SEC_CONSTRUCTOR
)
2971 if (bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
) != 0)
2973 native_relocs
= (Elf_External_Rel
*)
2974 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
2977 bfd_set_error (bfd_error_no_memory
);
2980 if (bfd_read ((PTR
) native_relocs
,
2981 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
)
2982 != sizeof (Elf_External_Rel
) * asect
->reloc_count
)
2985 reloc_cache
= (arelent
*)
2986 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2990 bfd_set_error (bfd_error_no_memory
);
2994 /* Get the offset of the start of the segment we are relocating to read in
2995 the implicit addend. */
2996 data_hdr
= &elf_section_data (asect
)->this_hdr
;
2997 data_off
= data_hdr
->sh_offset
;
2998 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
3001 elf_debug_section ("data section", -1, data_hdr
);
3004 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3006 #ifdef RELOC_PROCESSING
3007 Elf_Internal_Rel dst
;
3008 Elf_External_Rel
*src
;
3010 cache_ptr
= reloc_cache
+ idx
;
3011 src
= native_relocs
+ idx
;
3012 elf_swap_reloc_in (abfd
, src
, &dst
);
3014 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3016 Elf_Internal_Rel dst
;
3017 Elf_External_Rel
*src
;
3019 cache_ptr
= reloc_cache
+ idx
;
3020 src
= native_relocs
+ idx
;
3022 elf_swap_reloc_in (abfd
, src
, &dst
);
3024 if (asect
->flags
& SEC_RELOC
)
3026 /* relocatable, so the offset is off of the section */
3027 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
3031 /* non-relocatable, so the offset a virtual address */
3032 cache_ptr
->address
= dst
.r_offset
;
3035 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
3036 of zero points to the dummy symbol, which was not read into
3037 the symbol table SYMBOLS. */
3038 if (ELF_R_SYM (dst
.r_info
) == 0)
3039 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
3044 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
3046 /* Translate any ELF section symbol into a BFD section
3048 s
= *(cache_ptr
->sym_ptr_ptr
);
3049 if (s
->flags
& BSF_SECTION_SYM
)
3051 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
3052 s
= *cache_ptr
->sym_ptr_ptr
;
3053 if (s
->name
== 0 || s
->name
[0] == 0)
3057 BFD_ASSERT (dst
.r_offset
<= data_max
);
3058 cache_ptr
->addend
= 0;
3060 /* Fill in the cache_ptr->howto field from dst.r_type */
3062 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
3063 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
3068 asect
->relocation
= reloc_cache
;
3073 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3079 arelent
*tblptr
= section
->relocation
;
3080 unsigned int count
= 0;
3081 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
3083 /* snarfed from coffcode.h */
3086 if (! elf_slurp_reloca_table (abfd
, section
, symbols
))
3091 if (! elf_slurp_reloc_table (abfd
, section
, symbols
))
3095 tblptr
= section
->relocation
;
3097 for (; count
++ < section
->reloc_count
;)
3098 *relptr
++ = tblptr
++;
3101 return section
->reloc_count
;
3105 elf_get_symtab (abfd
, alocation
)
3107 asymbol
**alocation
;
3109 if (!elf_slurp_symbol_table (abfd
, alocation
))
3112 return bfd_get_symcount (abfd
);
3116 elf_make_empty_symbol (abfd
)
3119 elf_symbol_type
*newsym
;
3121 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3124 bfd_set_error (bfd_error_no_memory
);
3129 newsym
->symbol
.the_bfd
= abfd
;
3130 return &newsym
->symbol
;
3135 elf_get_symbol_info (ignore_abfd
, symbol
, ret
)
3140 bfd_symbol_info (symbol
, ret
);
3144 elf_print_symbol (ignore_abfd
, filep
, symbol
, how
)
3148 bfd_print_symbol_type how
;
3150 FILE *file
= (FILE *) filep
;
3153 case bfd_print_symbol_name
:
3154 fprintf (file
, "%s", symbol
->name
);
3156 case bfd_print_symbol_more
:
3157 fprintf (file
, "elf ");
3158 fprintf_vma (file
, symbol
->value
);
3159 fprintf (file
, " %lx", (long) symbol
->flags
);
3161 case bfd_print_symbol_all
:
3163 CONST
char *section_name
;
3164 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3165 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3166 fprintf (file
, " %s\t%s",
3176 elf_get_lineno (ignore_abfd
, symbol
)
3180 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3187 elf_set_arch_mach (abfd
, arch
, machine
)
3189 enum bfd_architecture arch
;
3190 unsigned long machine
;
3192 /* Allow any architecture to be supported by the elf backend */
3195 case bfd_arch_unknown
: /* EM_NONE */
3196 case bfd_arch_sparc
: /* EM_SPARC */
3197 case bfd_arch_i386
: /* EM_386 */
3198 case bfd_arch_m68k
: /* EM_68K */
3199 case bfd_arch_m88k
: /* EM_88K */
3200 case bfd_arch_i860
: /* EM_860 */
3201 case bfd_arch_mips
: /* EM_MIPS (MIPS R3000) */
3202 case bfd_arch_hppa
: /* EM_HPPA (HP PA_RISC) */
3203 case bfd_arch_powerpc
: /* EM_CYGNUS_POWERPC */
3204 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3211 elf_find_nearest_line (abfd
,
3222 CONST
char **filename_ptr
;
3223 CONST
char **functionname_ptr
;
3224 unsigned int *line_ptr
;
3230 elf_sizeof_headers (abfd
, reloc
)
3234 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
3241 elf_set_section_contents (abfd
, section
, location
, offset
, count
)
3246 bfd_size_type count
;
3248 Elf_Internal_Shdr
*hdr
;
3250 if (abfd
->output_has_begun
== false) /* set by bfd.c handler? */
3252 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3254 /* Do any elf backend specific processing first. */
3255 if (bed
->elf_backend_begin_write_processing
)
3256 (*bed
->elf_backend_begin_write_processing
) (abfd
);
3258 /* do setup calculations (FIXME) */
3259 if (prep_headers (abfd
) == false)
3261 if (elf_compute_section_file_positions (abfd
) == false)
3263 abfd
->output_has_begun
= true;
3266 hdr
= &elf_section_data (section
)->this_hdr
;
3268 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3270 if (bfd_write (location
, 1, count
, abfd
) != count
)
3277 elf_no_info_to_howto (abfd
, cache_ptr
, dst
)
3280 Elf_Internal_Rela
*dst
;
3282 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3288 elf_no_info_to_howto_rel (abfd
, cache_ptr
, dst
)
3291 Elf_Internal_Rel
*dst
;
3293 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3299 /* Core file support */
3301 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3302 #include <sys/procfs.h>
3304 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
3305 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
3306 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
3312 bfd_prstatus (abfd
, descdata
, descsz
, filepos
)
3319 prstatus_t
*status
= (prstatus_t
*) 0;
3321 if (descsz
== sizeof (prstatus_t
))
3323 newsect
= bfd_make_section (abfd
, ".reg");
3324 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3325 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3326 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3327 newsect
->alignment_power
= 2;
3328 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3330 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3335 /* Stash a copy of the prpsinfo structure away for future use. */
3338 bfd_prpsinfo (abfd
, descdata
, descsz
, filepos
)
3346 if (descsz
== sizeof (prpsinfo_t
))
3348 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3350 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3356 bfd_fpregset (abfd
, descdata
, descsz
, filepos
)
3364 newsect
= bfd_make_section (abfd
, ".reg2");
3365 newsect
->_raw_size
= descsz
;
3366 newsect
->filepos
= filepos
;
3367 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3368 newsect
->alignment_power
= 2;
3371 #endif /* HAVE_PROCFS */
3373 /* Return a pointer to the args (including the command name) that were
3374 seen by the program that generated the core dump. Note that for
3375 some reason, a spurious space is tacked onto the end of the args
3376 in some (at least one anyway) implementations, so strip it off if
3380 elf_core_file_failing_command (abfd
)
3384 if (core_prpsinfo (abfd
))
3386 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3387 char *scan
= p
->pr_psargs
;
3392 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3396 return p
->pr_psargs
;
3402 /* Return the number of the signal that caused the core dump. Presumably,
3403 since we have a core file, we got a signal of some kind, so don't bother
3404 checking the other process status fields, just return the signal number.
3408 elf_core_file_failing_signal (abfd
)
3412 if (core_prstatus (abfd
))
3414 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3420 /* Check to see if the core file could reasonably be expected to have
3421 come for the current executable file. Note that by default we return
3422 true unless we find something that indicates that there might be a
3427 elf_core_file_matches_executable_p (core_bfd
, exec_bfd
)
3436 /* First, xvecs must match since both are ELF files for the same target. */
3438 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3440 bfd_set_error (bfd_error_system_call
);
3446 /* If no prpsinfo, just return true. Otherwise, grab the last component
3447 of the exec'd pathname from the prpsinfo. */
3449 if (core_prpsinfo (core_bfd
))
3451 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3458 /* Find the last component of the executable pathname. */
3460 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3466 execname
= (char *) exec_bfd
->filename
;
3469 /* See if they match */
3471 return strcmp (execname
, corename
) ? false : true;
3477 #endif /* HAVE_PROCFS */
3480 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3481 the information that would normally be available from the /proc interface
3482 for the process, at the time the process dumped core. Currently this
3483 includes copies of the prstatus, prpsinfo, and fpregset structures.
3485 Since these structures are potentially machine dependent in size and
3486 ordering, bfd provides two levels of support for them. The first level,
3487 available on all machines since it does not require that the host
3488 have /proc support or the relevant include files, is to create a bfd
3489 section for each of the prstatus, prpsinfo, and fpregset structures,
3490 without any interpretation of their contents. With just this support,
3491 the bfd client will have to interpret the structures itself. Even with
3492 /proc support, it might want these full structures for it's own reasons.
3494 In the second level of support, where HAVE_PROCFS is defined, bfd will
3495 pick apart the structures to gather some additional information that
3496 clients may want, such as the general register set, the name of the
3497 exec'ed file and its arguments, the signal (if any) that caused the
3503 elf_corefile_note (abfd
, hdr
)
3505 Elf_Internal_Phdr
*hdr
;
3507 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3508 Elf_Internal_Note i_note
; /* Elf note, internal form */
3509 char *buf
= NULL
; /* Entire note segment contents */
3510 char *namedata
; /* Name portion of the note */
3511 char *descdata
; /* Descriptor portion of the note */
3512 char *sectname
; /* Name to use for new section */
3513 long filepos
; /* File offset to descriptor data */
3516 if (hdr
->p_filesz
> 0
3517 && (buf
= (char *) malloc (hdr
->p_filesz
)) != NULL
3518 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3519 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3521 x_note_p
= (Elf_External_Note
*) buf
;
3522 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3524 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3525 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3526 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3527 namedata
= x_note_p
->name
;
3528 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3529 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3530 switch (i_note
.type
)
3533 /* process descdata as prstatus info */
3534 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
3535 sectname
= ".prstatus";
3538 /* process descdata as fpregset info */
3539 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
3540 sectname
= ".fpregset";
3543 /* process descdata as prpsinfo */
3544 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
3545 sectname
= ".prpsinfo";
3548 /* Unknown descriptor, just ignore it. */
3552 if (sectname
!= NULL
)
3554 newsect
= bfd_make_section (abfd
, sectname
);
3555 newsect
->_raw_size
= i_note
.descsz
;
3556 newsect
->filepos
= filepos
;
3557 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3558 newsect
->alignment_power
= 2;
3560 x_note_p
= (Elf_External_Note
*)
3561 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3568 else if (hdr
->p_filesz
> 0)
3570 bfd_set_error (bfd_error_no_memory
);
3577 /* Core files are simply standard ELF formatted files that partition
3578 the file using the execution view of the file (program header table)
3579 rather than the linking view. In fact, there is no section header
3580 table in a core file.
3582 The process status information (including the contents of the general
3583 register set) and the floating point register set are stored in a
3584 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3585 that allow standard bfd access to the general registers (.reg) and the
3586 floating point registers (.reg2).
3591 elf_core_file_p (abfd
)
3594 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3595 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3596 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3597 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3598 unsigned int phindex
;
3599 struct elf_backend_data
*ebd
;
3601 /* Read in the ELF header in external format. */
3603 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3605 if (bfd_get_error () != bfd_error_system_call
)
3606 bfd_set_error (bfd_error_wrong_format
);
3610 /* Now check to see if we have a valid ELF file, and one that BFD can
3611 make use of. The magic number must match, the address size ('class')
3612 and byte-swapping must match our XVEC entry, and it must have a
3613 program header table (FIXME: See comments re segments at top of this
3616 if (elf_file_p (&x_ehdr
) == false)
3619 bfd_set_error (bfd_error_wrong_format
);
3623 /* FIXME, Check EI_VERSION here ! */
3627 int desired_address_size
= ELFCLASS32
;
3630 int desired_address_size
= ELFCLASS64
;
3633 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3637 /* Switch xvec to match the specified byte order. */
3638 switch (x_ehdr
.e_ident
[EI_DATA
])
3640 case ELFDATA2MSB
: /* Big-endian */
3641 if (abfd
->xvec
->byteorder_big_p
== false)
3644 case ELFDATA2LSB
: /* Little-endian */
3645 if (abfd
->xvec
->byteorder_big_p
== true)
3648 case ELFDATANONE
: /* No data encoding specified */
3649 default: /* Unknown data encoding specified */
3653 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3654 the tdata pointer in the bfd. */
3657 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3658 if (elf_tdata (abfd
) == NULL
)
3660 bfd_set_error (bfd_error_no_memory
);
3664 /* FIXME, `wrong' returns from this point onward, leak memory. */
3666 /* Now that we know the byte order, swap in the rest of the header */
3667 i_ehdrp
= elf_elfheader (abfd
);
3668 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3670 elf_debug_file (i_ehdrp
);
3673 ebd
= get_elf_backend_data (abfd
);
3675 /* Check that the ELF e_machine field matches what this particular
3676 BFD format expects. */
3677 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
3679 bfd_target
**target_ptr
;
3681 if (ebd
->elf_machine_code
!= EM_NONE
)
3684 /* This is the generic ELF target. Let it match any ELF target
3685 for which we do not have a specific backend. */
3686 for (target_ptr
= bfd_target_vector
; *target_ptr
!= NULL
; target_ptr
++)
3688 struct elf_backend_data
*back
;
3690 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
3692 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
3693 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
3695 /* target_ptr is an ELF backend which matches this
3696 object file, so reject the generic ELF target. */
3702 /* If there is no program header, or the type is not a core file, then
3704 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3707 /* Allocate space for a copy of the program header table in
3708 internal form, seek to the program header table in the file,
3709 read it in, and convert it to internal form. As a simple sanity
3710 check, verify that the what BFD thinks is the size of each program
3711 header table entry actually matches the size recorded in the file. */
3713 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3715 i_phdrp
= (Elf_Internal_Phdr
*)
3716 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3719 bfd_set_error (bfd_error_no_memory
);
3722 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3724 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3726 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3729 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3732 /* Once all of the program headers have been read and converted, we
3733 can start processing them. */
3735 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3737 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3738 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3740 elf_corefile_note (abfd
, i_phdrp
+ phindex
);
3744 /* Remember the entry point specified in the ELF file header. */
3746 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;