1 /* ELF executable support for BFD.
2 Copyright 1991, 1992, 1993 Free Software Foundation, Inc.
4 Written by Fred Fish @ Cygnus Support, from information published
5 in "UNIX System V Release 4, Programmers Guide: ANSI C and
6 Programming Support Tools". Sufficient support for gdb.
8 Rewritten by Mark Eichin @ Cygnus Support, from information
9 published in "System V Application Binary Interface", chapters 4
10 and 5, as well as the various "Processor Supplement" documents
11 derived from it. Added support for assembler and other object file
12 utilities. Further work done by Ken Raeburn (Cygnus Support), Michael
13 Meissner (Open Software Foundation), and Peter Hoogenboom (University
14 of Utah) to finish and extend this.
16 This file is part of BFD, the Binary File Descriptor library.
18 This program is free software; you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation; either version 2 of the License, or
21 (at your option) any later version.
23 This program is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with this program; if not, write to the Free Software
30 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
32 /* Problems and other issues to resolve.
34 (1) BFD expects there to be some fixed number of "sections" in
35 the object file. I.E. there is a "section_count" variable in the
36 bfd structure which contains the number of sections. However, ELF
37 supports multiple "views" of a file. In particular, with current
38 implementations, executable files typically have two tables, a
39 program header table and a section header table, both of which
40 partition the executable.
42 In ELF-speak, the "linking view" of the file uses the section header
43 table to access "sections" within the file, and the "execution view"
44 uses the program header table to access "segments" within the file.
45 "Segments" typically may contain all the data from one or more
48 Note that the section header table is optional in ELF executables,
49 but it is this information that is most useful to gdb. If the
50 section header table is missing, then gdb should probably try
51 to make do with the program header table. (FIXME)
53 (2) The code in this file is compiled twice, once in 32-bit mode and
54 once in 64-bit mode. More of it should be made size-independent
57 (3) ELF section symbols are handled rather sloppily now. This should
58 be cleaned up, and ELF section symbols reconciled with BFD section
63 #include <string.h> /* For strrchr and friends */
73 /* Renaming structures, typedefs, macros and functions to be size-specific. */
74 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
75 #define Elf_External_Sym NAME(Elf,External_Sym)
76 #define Elf_External_Shdr NAME(Elf,External_Shdr)
77 #define Elf_External_Phdr NAME(Elf,External_Phdr)
78 #define Elf_External_Rel NAME(Elf,External_Rel)
79 #define Elf_External_Rela NAME(Elf,External_Rela)
81 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
82 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
83 #define elf_core_file_matches_executable_p NAME(bfd_elf,core_file_matches_executable_p)
84 #define elf_object_p NAME(bfd_elf,object_p)
85 #define elf_core_file_p NAME(bfd_elf,core_file_p)
86 #define elf_get_symtab_upper_bound NAME(bfd_elf,get_symtab_upper_bound)
87 #define elf_get_reloc_upper_bound NAME(bfd_elf,get_reloc_upper_bound)
88 #define elf_canonicalize_reloc NAME(bfd_elf,canonicalize_reloc)
89 #define elf_get_symtab NAME(bfd_elf,get_symtab)
90 #define elf_make_empty_symbol NAME(bfd_elf,make_empty_symbol)
91 #define elf_get_symbol_info NAME(bfd_elf,get_symbol_info)
92 #define elf_print_symbol NAME(bfd_elf,print_symbol)
93 #define elf_get_lineno NAME(bfd_elf,get_lineno)
94 #define elf_set_arch_mach NAME(bfd_elf,set_arch_mach)
95 #define elf_find_nearest_line NAME(bfd_elf,find_nearest_line)
96 #define elf_sizeof_headers NAME(bfd_elf,sizeof_headers)
97 #define elf_set_section_contents NAME(bfd_elf,set_section_contents)
98 #define elf_no_info_to_howto NAME(bfd_elf,no_info_to_howto)
99 #define elf_no_info_to_howto_rel NAME(bfd_elf,no_info_to_howto_rel)
100 #define elf_new_section_hook NAME(bfd_elf,new_section_hook)
101 #define write_relocs NAME(bfd_elf,_write_relocs)
102 #define elf_find_section NAME(bfd_elf,find_section)
105 #define ELF_R_INFO(X,Y) ELF64_R_INFO(X,Y)
106 #define ELF_R_SYM(X) ELF64_R_SYM(X)
107 #define ELFCLASS ELFCLASS64
111 #define ELF_R_INFO(X,Y) ELF32_R_INFO(X,Y)
112 #define ELF_R_SYM(X) ELF32_R_SYM(X)
113 #define ELFCLASS ELFCLASS32
117 static int shstrtab_length_fixed
;
119 struct elf_sect_data
{
124 /* Forward declarations of static functions */
126 static struct sec
* section_from_elf_index
PARAMS ((bfd
*, int));
128 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
130 static boolean elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**));
132 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
133 struct symbol_cache_entry
**));
135 static void elf_map_symbols
PARAMS ((bfd
*));
136 static void swap_out_syms
PARAMS ((bfd
*));
139 static void elf_debug_section
PARAMS ((char *, int, Elf_Internal_Shdr
*));
140 static void elf_debug_file
PARAMS ((Elf_Internal_Ehdr
*));
143 #define elf_string_from_elf_strtab(abfd,strindex) \
144 elf_string_from_elf_section(abfd,elf_elfheader(abfd)->e_shstrndx,strindex)
147 /* Structure swapping routines */
149 /* Should perhaps use put_offset, put_word, etc. For now, the two versions
150 can be handled by explicitly specifying 32 bits or "the long type". */
152 #define put_word bfd_h_put_64
153 #define get_word bfd_h_get_64
156 #define put_word bfd_h_put_32
157 #define get_word bfd_h_get_32
160 /* Translate an ELF symbol in external format into an ELF symbol in internal
164 DEFUN (elf_swap_symbol_in
, (abfd
, src
, dst
),
166 Elf_External_Sym
* src AND
167 Elf_Internal_Sym
* dst
)
169 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
170 dst
->st_value
= get_word (abfd
, (bfd_byte
*) src
->st_value
);
171 dst
->st_size
= get_word (abfd
, (bfd_byte
*) src
->st_size
);
172 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
173 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
174 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
177 /* Translate an ELF symbol in internal format into an ELF symbol in external
181 DEFUN (elf_swap_symbol_out
, (abfd
, src
, dst
),
183 Elf_Internal_Sym
* src AND
184 Elf_External_Sym
* dst
)
186 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
187 put_word (abfd
, src
->st_value
, dst
->st_value
);
188 put_word (abfd
, src
->st_size
, dst
->st_size
);
189 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
190 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
191 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
195 /* Translate an ELF file header in external format into an ELF file header in
199 DEFUN (elf_swap_ehdr_in
, (abfd
, src
, dst
),
201 Elf_External_Ehdr
* src AND
202 Elf_Internal_Ehdr
* dst
)
204 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
205 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
206 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
207 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
208 dst
->e_entry
= get_word (abfd
, (bfd_byte
*) src
->e_entry
);
209 dst
->e_phoff
= get_word (abfd
, (bfd_byte
*) src
->e_phoff
);
210 dst
->e_shoff
= get_word (abfd
, (bfd_byte
*) src
->e_shoff
);
211 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
212 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
213 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
214 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
215 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
216 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
217 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
220 /* Translate an ELF file header in internal format into an ELF file header in
224 DEFUN (elf_swap_ehdr_out
, (abfd
, src
, dst
),
226 Elf_Internal_Ehdr
* src AND
227 Elf_External_Ehdr
* dst
)
229 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
230 /* note that all elements of dst are *arrays of unsigned char* already... */
231 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
232 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
233 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
234 put_word (abfd
, src
->e_entry
, dst
->e_entry
);
235 put_word (abfd
, src
->e_phoff
, dst
->e_phoff
);
236 put_word (abfd
, src
->e_shoff
, dst
->e_shoff
);
237 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
238 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
239 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
240 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
241 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
242 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
243 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
247 /* Translate an ELF section header table entry in external format into an
248 ELF section header table entry in internal format. */
251 DEFUN (elf_swap_shdr_in
, (abfd
, src
, dst
),
253 Elf_External_Shdr
* src AND
254 Elf_Internal_Shdr
* dst
)
256 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
257 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
258 dst
->sh_flags
= get_word (abfd
, (bfd_byte
*) src
->sh_flags
);
259 dst
->sh_addr
= get_word (abfd
, (bfd_byte
*) src
->sh_addr
);
260 dst
->sh_offset
= get_word (abfd
, (bfd_byte
*) src
->sh_offset
);
261 dst
->sh_size
= get_word (abfd
, (bfd_byte
*) src
->sh_size
);
262 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
263 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
264 dst
->sh_addralign
= get_word (abfd
, (bfd_byte
*) src
->sh_addralign
);
265 dst
->sh_entsize
= get_word (abfd
, (bfd_byte
*) src
->sh_entsize
);
266 /* we haven't done any processing on it yet, so... */
267 dst
->rawdata
= (void *) 0;
270 /* Translate an ELF section header table entry in internal format into an
271 ELF section header table entry in external format. */
274 DEFUN (elf_swap_shdr_out
, (abfd
, src
, dst
),
276 Elf_Internal_Shdr
* src AND
277 Elf_External_Shdr
* dst
)
279 /* note that all elements of dst are *arrays of unsigned char* already... */
280 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
281 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
282 put_word (abfd
, src
->sh_flags
, dst
->sh_flags
);
283 put_word (abfd
, src
->sh_addr
, dst
->sh_addr
);
284 put_word (abfd
, src
->sh_offset
, dst
->sh_offset
);
285 put_word (abfd
, src
->sh_size
, dst
->sh_size
);
286 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
287 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
288 put_word (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
289 put_word (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
293 /* Translate an ELF program header table entry in external format into an
294 ELF program header table entry in internal format. */
297 DEFUN (elf_swap_phdr_in
, (abfd
, src
, dst
),
299 Elf_External_Phdr
* src AND
300 Elf_Internal_Phdr
* dst
)
302 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
303 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
304 dst
->p_offset
= get_word (abfd
, (bfd_byte
*) src
->p_offset
);
305 dst
->p_vaddr
= get_word (abfd
, (bfd_byte
*) src
->p_vaddr
);
306 dst
->p_paddr
= get_word (abfd
, (bfd_byte
*) src
->p_paddr
);
307 dst
->p_filesz
= get_word (abfd
, (bfd_byte
*) src
->p_filesz
);
308 dst
->p_memsz
= get_word (abfd
, (bfd_byte
*) src
->p_memsz
);
309 dst
->p_align
= get_word (abfd
, (bfd_byte
*) src
->p_align
);
313 DEFUN (elf_swap_phdr_out
, (abfd
, src
, dst
),
315 Elf_Internal_Phdr
* src AND
316 Elf_External_Phdr
* dst
)
318 /* note that all elements of dst are *arrays of unsigned char* already... */
319 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
320 put_word (abfd
, src
->p_offset
, dst
->p_offset
);
321 put_word (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
322 put_word (abfd
, src
->p_paddr
, dst
->p_paddr
);
323 put_word (abfd
, src
->p_filesz
, dst
->p_filesz
);
324 put_word (abfd
, src
->p_memsz
, dst
->p_memsz
);
325 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
326 put_word (abfd
, src
->p_align
, dst
->p_align
);
329 /* Translate an ELF reloc from external format to internal format. */
331 DEFUN (elf_swap_reloc_in
, (abfd
, src
, dst
),
333 Elf_External_Rel
* src AND
334 Elf_Internal_Rel
* dst
)
336 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
337 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
341 DEFUN (elf_swap_reloca_in
, (abfd
, src
, dst
),
343 Elf_External_Rela
* src AND
344 Elf_Internal_Rela
* dst
)
346 dst
->r_offset
= get_word (abfd
, (bfd_byte
*) src
->r_offset
);
347 dst
->r_info
= get_word (abfd
, (bfd_byte
*) src
->r_info
);
348 dst
->r_addend
= get_word (abfd
, (bfd_byte
*) src
->r_addend
);
351 /* Translate an ELF reloc from internal format to external format. */
353 DEFUN (elf_swap_reloc_out
, (abfd
, src
, dst
),
355 Elf_Internal_Rel
* src AND
356 Elf_External_Rel
* dst
)
358 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
359 put_word (abfd
, src
->r_info
, dst
->r_info
);
363 DEFUN (elf_swap_reloca_out
, (abfd
, src
, dst
),
365 Elf_Internal_Rela
* src AND
366 Elf_External_Rela
* dst
)
368 put_word (abfd
, src
->r_offset
, dst
->r_offset
);
369 put_word (abfd
, src
->r_info
, dst
->r_info
);
370 put_word (abfd
, src
->r_addend
, dst
->r_addend
);
375 /* String table creation/manipulation routines */
377 static struct strtab
*
378 DEFUN (bfd_new_strtab
, (abfd
),
383 ss
= (struct strtab
*) bfd_xmalloc (sizeof (struct strtab
));
384 ss
->tab
= bfd_xmalloc (1);
385 BFD_ASSERT (ss
->tab
!= 0);
394 DEFUN (bfd_add_to_strtab
, (abfd
, ss
, str
),
396 struct strtab
*ss AND
399 /* should search first, but for now: */
400 /* include the trailing NUL */
401 int ln
= strlen (str
) + 1;
403 /* should this be using obstacks? */
404 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
406 BFD_ASSERT (ss
->tab
!= 0);
407 strcpy (ss
->tab
+ ss
->length
, str
);
411 return ss
->length
- ln
;
415 DEFUN (bfd_add_2_to_strtab
, (abfd
, ss
, str
, str2
),
417 struct strtab
*ss AND
421 /* should search first, but for now: */
422 /* include the trailing NUL */
423 int ln
= strlen (str
) + strlen (str2
) + 1;
425 /* should this be using obstacks? */
427 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
429 ss
->tab
= bfd_xmalloc (ln
);
431 BFD_ASSERT (ss
->tab
!= 0);
432 strcpy (ss
->tab
+ ss
->length
, str
);
433 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
437 return ss
->length
- ln
;
441 /* ELF .o/exec file reading */
443 /* Create a new bfd section from an ELF section header. */
446 DEFUN (bfd_section_from_shdr
, (abfd
, shindex
),
448 unsigned int shindex
)
450 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[shindex
];
451 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
455 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
457 switch (hdr
->sh_type
)
461 /* inactive section. Throw it away. */
465 /* Bits that get saved. This one is real. */
468 newsect
= bfd_make_section (abfd
, name
);
471 newsect
->filepos
= hdr
->sh_offset
; /* so we can read back the bits */
472 newsect
->flags
|= SEC_HAS_CONTENTS
;
473 newsect
->vma
= hdr
->sh_addr
;
474 newsect
->_raw_size
= hdr
->sh_size
;
475 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
477 if (hdr
->sh_flags
& SHF_ALLOC
)
479 newsect
->flags
|= SEC_ALLOC
;
480 newsect
->flags
|= SEC_LOAD
;
483 if (!(hdr
->sh_flags
& SHF_WRITE
))
484 newsect
->flags
|= SEC_READONLY
;
486 if (hdr
->sh_flags
& SHF_EXECINSTR
)
487 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
488 else if (newsect
->flags
& SEC_ALLOC
)
489 newsect
->flags
|= SEC_DATA
;
491 /* The debugging sections appear to recognized only by
493 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
494 || strncmp (name
, ".line", sizeof ".line" - 1) == 0
495 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
496 newsect
->flags
|= SEC_DEBUGGING
;
498 hdr
->rawdata
= (void *) newsect
;
501 hdr
->rawdata
= (void *) bfd_get_section_by_name (abfd
, name
);
506 /* Bits that get saved. This one is real. */
509 newsect
= bfd_make_section (abfd
, name
);
512 newsect
->vma
= hdr
->sh_addr
;
513 newsect
->_raw_size
= hdr
->sh_size
;
514 newsect
->filepos
= hdr
->sh_offset
; /* fake */
515 newsect
->alignment_power
= bfd_log2 (hdr
->sh_addralign
);
516 if (hdr
->sh_flags
& SHF_ALLOC
)
517 newsect
->flags
|= SEC_ALLOC
;
519 if (!(hdr
->sh_flags
& SHF_WRITE
))
520 newsect
->flags
|= SEC_READONLY
;
522 /* FIXME: This section is empty. Does it really make
523 sense to set SEC_CODE for it? */
524 if (hdr
->sh_flags
& SHF_EXECINSTR
)
525 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
527 hdr
->rawdata
= (void *) newsect
;
532 case SHT_SYMTAB
: /* A symbol table */
533 if (elf_onesymtab (abfd
) == shindex
)
536 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
537 BFD_ASSERT (elf_onesymtab (abfd
) == 0);
538 elf_onesymtab (abfd
) = shindex
;
539 elf_tdata(abfd
)->symtab_hdr
= *hdr
;
540 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->symtab_hdr
;
541 abfd
->flags
|= HAS_SYMS
;
544 case SHT_STRTAB
: /* A string table */
547 if (ehdr
->e_shstrndx
== shindex
)
549 elf_tdata(abfd
)->shstrtab_hdr
= *hdr
;
550 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->shstrtab_hdr
;
551 hdr
->rawdata
= (PTR
) &elf_tdata(abfd
)->shstrtab_hdr
;
557 for (i
= 1; i
< ehdr
->e_shnum
; i
++)
559 Elf_Internal_Shdr
*hdr2
= elf_elfsections(abfd
)[i
];
560 if (hdr2
->sh_link
== shindex
)
562 bfd_section_from_shdr (abfd
, i
);
563 if (elf_onesymtab (abfd
) == i
)
565 elf_tdata(abfd
)->strtab_hdr
= *hdr
;
566 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->strtab_hdr
;
569 #if 0 /* Not handling other string tables specially right now. */
570 hdr2
= elf_elfsections(abfd
)[i
]; /* in case it moved */
571 /* We have a strtab for some random other section. */
572 newsect
= (asection
*) hdr2
->rawdata
;
575 hdr
->rawdata
= (PTR
) newsect
;
576 hdr2
= &elf_section_data (newsect
)->str_hdr
;
578 elf_elfsections(abfd
)[shindex
] = hdr2
;
584 newsect
= bfd_make_section (abfd
, name
);
587 newsect
->flags
= SEC_HAS_CONTENTS
;
588 hdr
->rawdata
= (PTR
) newsect
;
589 newsect
->_raw_size
= hdr
->sh_size
;
590 newsect
->alignment_power
= 0;
592 newsect
->filepos
= hdr
->sh_offset
;
594 if (hdr
->sh_flags
& SHF_ALLOC
)
595 newsect
->flags
|= SEC_ALLOC
|SEC_LOAD
;
596 if (!(hdr
->sh_flags
& SHF_WRITE
))
597 newsect
->flags
|= SEC_READONLY
;
598 if (hdr
->sh_flags
& SHF_EXECINSTR
)
599 newsect
->flags
|= SEC_CODE
;
600 else if (newsect
->flags
& SEC_ALLOC
)
601 newsect
->flags
|= SEC_DATA
;
603 /* Check for debugging string tables. */
604 if (strncmp (name
, ".debug", sizeof ".debug" - 1) == 0
605 || strncmp (name
, ".stab", sizeof ".stab" - 1) == 0)
606 newsect
->flags
|= SEC_DEBUGGING
;
613 /* *These* do a lot of work -- but build no sections!
614 The spec says there can be multiple strtabs, but only one symtab,
615 but there can be lots of REL* sections. */
616 /* FIXME: The above statement is wrong! There are typically at least
617 two symbol tables in a dynamically linked executable, ".dynsym"
618 which is the dynamic linkage symbol table and ".symtab", which is
619 the "traditional" symbol table. -fnf */
622 asection
*target_sect
;
623 Elf_Internal_Shdr
*hdr2
;
624 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
626 /* Don't allow REL relocations on a machine that uses RELA and
628 /* @@ Actually, the generic ABI does suggest that both might be
629 used in one file. But the four ABI Processor Supplements I
630 have access to right now all specify that only one is used on
631 each of those architectures. It's conceivable that, e.g., a
632 bunch of absolute 32-bit relocs might be more compact in REL
633 form even on a RELA machine... */
634 BFD_ASSERT (!(use_rela_p
&& (hdr
->sh_type
== SHT_REL
)));
635 BFD_ASSERT (!(!use_rela_p
&& (hdr
->sh_type
== SHT_RELA
)));
636 BFD_ASSERT (hdr
->sh_entsize
==
638 ? sizeof (Elf_External_Rela
)
639 : sizeof (Elf_External_Rel
)));
641 bfd_section_from_shdr (abfd
, hdr
->sh_info
); /* target */
642 bfd_section_from_shdr (abfd
, hdr
->sh_link
); /* symbol table */
643 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
644 if (target_sect
== NULL
645 || elf_section_data (target_sect
) == NULL
)
648 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
650 elf_elfsections(abfd
)[shindex
] = hdr2
;
651 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
652 target_sect
->flags
|= SEC_RELOC
;
653 target_sect
->relocation
= 0;
654 target_sect
->rel_filepos
= hdr
->sh_offset
;
655 abfd
->flags
|= HAS_RELOC
;
662 case SHT_DYNSYM
: /* could treat this like symtab... */
664 fprintf (stderr
, "Dynamic Linking sections not yet supported.\n");
671 fprintf (stderr
, "Note Sections not yet supported.\n");
678 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
683 /* Check for any processor-specific section types. */
685 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
687 if (bed
->elf_backend_section_from_shdr
)
688 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
697 DEFUN (elf_new_section_hook
, (abfd
, sec
),
701 struct bfd_elf_section_data
*sdata
;
703 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
704 sec
->used_by_bfd
= (PTR
) sdata
;
705 memset (sdata
, 0, sizeof (*sdata
));
709 /* Create a new bfd section from an ELF program header.
711 Since program segments have no names, we generate a synthetic name
712 of the form segment<NUM>, where NUM is generally the index in the
713 program header table. For segments that are split (see below) we
714 generate the names segment<NUM>a and segment<NUM>b.
716 Note that some program segments may have a file size that is different than
717 (less than) the memory size. All this means is that at execution the
718 system must allocate the amount of memory specified by the memory size,
719 but only initialize it with the first "file size" bytes read from the
720 file. This would occur for example, with program segments consisting
721 of combined data+bss.
723 To handle the above situation, this routine generates TWO bfd sections
724 for the single program segment. The first has the length specified by
725 the file size of the segment, and the second has the length specified
726 by the difference between the two sizes. In effect, the segment is split
727 into it's initialized and uninitialized parts.
732 DEFUN (bfd_section_from_phdr
, (abfd
, hdr
, index
),
734 Elf_Internal_Phdr
* hdr AND
742 split
= ((hdr
->p_memsz
> 0) &&
743 (hdr
->p_filesz
> 0) &&
744 (hdr
->p_memsz
> hdr
->p_filesz
));
745 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
746 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
747 strcpy (name
, namebuf
);
748 newsect
= bfd_make_section (abfd
, name
);
749 newsect
->vma
= hdr
->p_vaddr
;
750 newsect
->_raw_size
= hdr
->p_filesz
;
751 newsect
->filepos
= hdr
->p_offset
;
752 newsect
->flags
|= SEC_HAS_CONTENTS
;
753 if (hdr
->p_type
== PT_LOAD
)
755 newsect
->flags
|= SEC_ALLOC
;
756 newsect
->flags
|= SEC_LOAD
;
757 if (hdr
->p_flags
& PF_X
)
759 /* FIXME: all we known is that it has execute PERMISSION,
761 newsect
->flags
|= SEC_CODE
;
764 if (!(hdr
->p_flags
& PF_W
))
766 newsect
->flags
|= SEC_READONLY
;
771 sprintf (namebuf
, "segment%db", index
);
772 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
773 strcpy (name
, namebuf
);
774 newsect
= bfd_make_section (abfd
, name
);
775 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
776 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
777 if (hdr
->p_type
== PT_LOAD
)
779 newsect
->flags
|= SEC_ALLOC
;
780 if (hdr
->p_flags
& PF_X
)
781 newsect
->flags
|= SEC_CODE
;
783 if (!(hdr
->p_flags
& PF_W
))
784 newsect
->flags
|= SEC_READONLY
;
790 /* Begin processing a given object.
792 First we validate the file by reading in the ELF header and checking
795 static INLINE boolean
796 DEFUN (elf_file_p
, (x_ehdrp
), Elf_External_Ehdr
* x_ehdrp
)
798 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
799 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
800 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
801 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
804 /* Check to see if the file associated with ABFD matches the target vector
807 Note that we may be called several times with the same ABFD, but different
808 target vectors, most of which will not match. We have to avoid leaving
809 any side effects in ABFD, or any data it points to (like tdata), if the
810 file does not match the target vector.
812 FIXME: There is memory leak if we are called more than once with the same
813 ABFD, and that bfd already has tdata allocated, since we allocate more tdata
814 and the old tdata is orphaned. Since it's in the bfd obstack, there isn't
815 much we can do about this except possibly rewrite the code. There are
816 also other bfd_allocs that may be the source of memory leaks as well. */
819 DEFUN (elf_object_p
, (abfd
), bfd
* abfd
)
821 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
822 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
823 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
824 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
826 char *shstrtab
; /* Internal copy of section header stringtab */
827 struct elf_backend_data
*ebd
;
828 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
830 /* Read in the ELF header in external format. */
832 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
833 goto got_system_call_error
;
835 /* Now check to see if we have a valid ELF file, and one that BFD can
836 make use of. The magic number must match, the address size ('class')
837 and byte-swapping must match our XVEC entry, and it must have a
838 section header table (FIXME: See comments re sections at top of this
841 if ((elf_file_p (&x_ehdr
) == false) ||
842 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
843 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
844 goto got_wrong_format_error
;
846 /* Check that file's byte order matches xvec's */
847 switch (x_ehdr
.e_ident
[EI_DATA
])
849 case ELFDATA2MSB
: /* Big-endian */
850 if (!abfd
->xvec
->header_byteorder_big_p
)
851 goto got_wrong_format_error
;
853 case ELFDATA2LSB
: /* Little-endian */
854 if (abfd
->xvec
->header_byteorder_big_p
)
855 goto got_wrong_format_error
;
857 case ELFDATANONE
: /* No data encoding specified */
858 default: /* Unknown data encoding specified */
859 goto got_wrong_format_error
;
862 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
863 the tdata pointer in the bfd. FIXME: memory leak, see above. */
866 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
867 if (elf_tdata (abfd
) == NULL
)
868 goto got_no_memory_error
;
870 /* Now that we know the byte order, swap in the rest of the header */
871 i_ehdrp
= elf_elfheader (abfd
);
872 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
874 elf_debug_file (i_ehdrp
);
877 /* If there is no section header table, we're hosed. */
878 if (i_ehdrp
->e_shoff
== 0)
879 goto got_wrong_format_error
;
881 /* As a simple sanity check, verify that the what BFD thinks is the
882 size of each section header table entry actually matches the size
883 recorded in the file. */
884 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
885 goto got_wrong_format_error
;
887 ebd
= get_elf_backend_data (abfd
);
889 /* Check that the ELF e_machine field matches what this particular
890 BFD format expects. */
891 if (ebd
->elf_machine_code
!= i_ehdrp
->e_machine
)
893 bfd_target
**target_ptr
;
895 if (ebd
->elf_machine_code
!= EM_NONE
)
896 goto got_wrong_format_error
;
898 /* This is the generic ELF target. Let it match any ELF target
899 for which we do not have a specific backend. */
900 for (target_ptr
= target_vector
; *target_ptr
!= NULL
; target_ptr
++)
902 struct elf_backend_data
*back
;
904 if ((*target_ptr
)->flavour
!= bfd_target_elf_flavour
)
906 back
= (struct elf_backend_data
*) (*target_ptr
)->backend_data
;
907 if (back
->elf_machine_code
== i_ehdrp
->e_machine
)
909 /* target_ptr is an ELF backend which matches this
910 object file, so reject the generic ELF target. */
911 goto got_wrong_format_error
;
917 /* Set the flags and architecture before calling the backend so that
918 it can override them. */
919 if (i_ehdrp
->e_type
== ET_EXEC
)
920 abfd
->flags
|= EXEC_P
;
921 else if (i_ehdrp
->e_type
== ET_DYN
)
922 abfd
->flags
|= DYNAMIC
;
924 bfd_default_set_arch_mach (abfd
, ebd
->arch
, 0);
926 /* Remember the entry point specified in the ELF file header. */
927 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
929 /* Let the backend double check the format and override global
931 if (ebd
->elf_backend_object_p
)
933 if ((*ebd
->elf_backend_object_p
) (abfd
) == false)
934 goto got_wrong_format_error
;
937 /* Allocate space for a copy of the section header table in
938 internal form, seek to the section header table in the file,
939 read it in, and convert it to internal form. */
940 i_shdrp
= (Elf_Internal_Shdr
*)
941 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
);
942 elf_elfsections (abfd
) =
943 (Elf_Internal_Shdr
**) bfd_alloc (abfd
, sizeof (i_shdrp
) * i_ehdrp
->e_shnum
);
944 if (!i_shdrp
|| !elf_elfsections(abfd
))
945 goto got_no_memory_error
;
946 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) == -1)
947 goto got_system_call_error
;
948 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
950 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
951 goto got_system_call_error
;
952 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
953 elf_elfsections(abfd
)[shindex
] = i_shdrp
+ shindex
;
955 if (i_ehdrp
->e_shstrndx
)
957 bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
);
961 for (shindex
= i_ehdrp
->e_shnum
- 1; shindex
>= 0; shindex
--)
963 if (!strcmp (elf_string_from_elf_strtab (abfd
,
964 i_shdrp
[shindex
].sh_name
),
967 elf_tdata(abfd
)->strtab_hdr
= i_shdrp
[shindex
];
968 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->strtab_hdr
;
970 else if (!strcmp (elf_string_from_elf_strtab (abfd
,
971 i_shdrp
[shindex
].sh_name
),
974 elf_tdata(abfd
)->symtab_hdr
= i_shdrp
[shindex
];
975 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->symtab_hdr
;
976 elf_onesymtab (abfd
) = shindex
;
981 /* Read in the string table containing the names of the sections. We
982 will need the base pointer to this table later. */
983 /* We read this inline now, so that we don't have to go through
984 bfd_section_from_shdr with it (since this particular strtab is
985 used to find all of the ELF section names.) */
987 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
989 goto got_wrong_format_error
;
991 /* Once all of the section headers have been read and converted, we
992 can start processing them. Note that the first section header is
993 a dummy placeholder entry, so we ignore it.
995 We also watch for the symbol table section and remember the file
996 offset and section size for both the symbol table section and the
997 associated string table section. */
999 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1001 bfd_section_from_shdr (abfd
, shindex
);
1004 return (abfd
->xvec
);
1006 /* If we are going to use goto's to avoid duplicating error setting
1007 and return(NULL) code, then this at least makes it more maintainable. */
1009 got_system_call_error
:
1010 bfd_error
= system_call_error
;
1012 got_wrong_format_error
:
1013 bfd_error
= wrong_format
;
1015 got_no_memory_error
:
1016 bfd_error
= no_memory
;
1019 elf_tdata (abfd
) = preserved_tdata
;
1024 /* ELF .o/exec file writing */
1026 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1027 of the symbol if there is one. */
1028 static INLINE elf_symbol_type
*
1029 DEFUN (elf_symbol_from
, (ignore_abfd
, symbol
),
1030 bfd
* ignore_abfd AND
1033 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1036 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1039 return (elf_symbol_type
*) symbol
;
1042 /* Create ELF output from BFD sections.
1044 Essentially, just create the section header and forget about the program
1048 DEFUN (elf_make_sections
, (abfd
, asect
, obj
),
1050 asection
* asect AND
1053 /* most of what is in bfd_shdr_from_section goes in here... */
1054 /* and all of these sections generate at *least* one ELF section. */
1055 Elf_Internal_Shdr
*this_hdr
;
1056 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1058 this_hdr
->sh_addr
= asect
->vma
;
1059 this_hdr
->sh_size
= asect
->_raw_size
;
1060 /* contents already set by elf_set_section_contents */
1062 if (asect
->flags
& SEC_RELOC
)
1064 /* emit a reloc section, and thus strtab and symtab... */
1065 Elf_Internal_Shdr
*rela_hdr
;
1066 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1068 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1070 /* orelocation has the data, reloc_count has the count... */
1073 rela_hdr
->sh_type
= SHT_RELA
;
1074 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1077 /* REL relocations */
1079 rela_hdr
->sh_type
= SHT_REL
;
1080 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1082 rela_hdr
->sh_flags
= 0;
1083 rela_hdr
->sh_addr
= 0;
1084 rela_hdr
->sh_offset
= 0;
1086 /* FIXME: Systems I've checked use an alignment of 4, but it is
1087 possible that some systems use a different alignment. */
1088 rela_hdr
->sh_addralign
= 4;
1092 if (asect
->flags
& SEC_ALLOC
)
1094 this_hdr
->sh_flags
|= SHF_ALLOC
;
1095 if (asect
->flags
& SEC_LOAD
)
1097 /* @@ Do something with sh_type? */
1102 /* If this section is not part of the program image during
1103 execution, leave the address fields at 0. */
1104 this_hdr
->sh_addr
= 0;
1107 if (!(asect
->flags
& SEC_READONLY
))
1108 this_hdr
->sh_flags
|= SHF_WRITE
;
1110 if (asect
->flags
& SEC_CODE
)
1111 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1115 write_relocs (abfd
, sec
, xxx
)
1120 Elf_Internal_Shdr
*rela_hdr
;
1121 Elf_External_Rela
*outbound_relocas
;
1122 Elf_External_Rel
*outbound_relocs
;
1124 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1125 asymbol
*last_sym
= 0;
1128 if ((sec
->flags
& SEC_RELOC
) == 0)
1130 /* Flags are sometimes inconsistent. */
1131 if (sec
->reloc_count
== 0)
1134 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1136 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1137 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1139 /* orelocation has the data, reloc_count has the count... */
1142 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1144 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1146 Elf_Internal_Rela dst_rela
;
1147 Elf_External_Rela
*src_rela
;
1152 ptr
= sec
->orelocation
[idx
];
1153 src_rela
= outbound_relocas
+ idx
;
1154 if (!(abfd
->flags
& EXEC_P
))
1155 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1157 dst_rela
.r_offset
= ptr
->address
;
1159 sym
= *ptr
->sym_ptr_ptr
;
1160 if (sym
== last_sym
)
1165 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1167 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1169 dst_rela
.r_addend
= ptr
->addend
;
1170 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1174 /* REL relocations */
1176 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1178 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1180 Elf_Internal_Rel dst_rel
;
1181 Elf_External_Rel
*src_rel
;
1186 ptr
= sec
->orelocation
[idx
];
1187 sym
= *ptr
->sym_ptr_ptr
;
1188 src_rel
= outbound_relocs
+ idx
;
1189 if (!(abfd
->flags
& EXEC_P
))
1190 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1192 dst_rel
.r_offset
= ptr
->address
;
1194 if (sym
== last_sym
)
1199 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1201 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1203 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1209 fix_up_strtabs (abfd
, asect
, obj
)
1214 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (asect
)->this_hdr
;
1215 int this_idx
= elf_section_data(asect
)->this_idx
;
1217 /* @@ Check flags! */
1218 if (!strncmp (asect
->name
, ".stab", 5)
1219 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
1221 size_t len
= strlen (asect
->name
) + 1;
1222 char *s
= (char *) alloca (len
);
1223 strcpy (s
, asect
->name
);
1225 asect
= bfd_get_section_by_name (abfd
, s
);
1228 elf_section_data(asect
)->this_hdr
.sh_link
= this_idx
;
1229 /* @@ Assuming 32 bits! */
1230 elf_section_data(asect
)->this_hdr
.sh_entsize
= 0xc;
1232 this_hdr
->sh_type
= SHT_STRTAB
;
1237 DEFUN (elf_fake_sections
, (abfd
, asect
, obj
),
1239 asection
* asect AND
1242 /* most of what is in bfd_shdr_from_section goes in here... */
1243 /* and all of these sections generate at *least* one ELF section. */
1245 Elf_Internal_Shdr
*this_hdr
;
1246 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1248 bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
), asect
->name
);
1249 /* We need to log the type *now* so that elf_section_from_bfd_section
1250 can find us... have to set rawdata too. */
1251 this_hdr
->rawdata
= (void *) asect
;
1252 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1253 if ((asect
->flags
& SEC_ALLOC
) && (asect
->flags
& SEC_LOAD
))
1254 this_hdr
->sh_type
= SHT_PROGBITS
;
1255 else if ((asect
->flags
& SEC_ALLOC
) && ((asect
->flags
& SEC_LOAD
) == 0))
1257 BFD_ASSERT (!strcmp (asect
->name
, ".bss"));
1258 this_hdr
->sh_type
= SHT_NOBITS
;
1260 /* FIXME I am not sure how to detect a .note section from the flags
1261 word of an `asection'. */
1262 else if (!strcmp (asect
->name
, ".note"))
1263 this_hdr
->sh_type
= SHT_NOTE
;
1265 this_hdr
->sh_type
= SHT_PROGBITS
;
1267 this_hdr
->sh_flags
= 0;
1268 this_hdr
->sh_addr
= 0;
1269 this_hdr
->sh_size
= 0;
1270 this_hdr
->sh_entsize
= 0;
1271 this_hdr
->sh_info
= 0;
1272 this_hdr
->sh_link
= 0;
1273 this_hdr
->sh_offset
= 0;
1276 /* Now, check for processor-specific section types. */
1278 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1280 if (bed
->elf_backend_fake_sections
)
1281 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1285 /* Emit a strtab and symtab, and possibly a reloc section. */
1286 Elf_Internal_Shdr
*rela_hdr
;
1288 /* Note that only one symtab is used, so just remember it
1291 if (asect
->flags
& SEC_RELOC
)
1293 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1295 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1297 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1298 use_rela_p
? ".rela" : ".rel",
1300 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1301 rela_hdr
->sh_entsize
= (use_rela_p
1302 ? sizeof (Elf_External_Rela
)
1303 : sizeof (Elf_External_Rel
));
1305 rela_hdr
->sh_flags
= 0;
1306 rela_hdr
->sh_addr
= 0;
1307 rela_hdr
->sh_size
= 0;
1308 rela_hdr
->sh_offset
= 0;
1310 /* FIXME: Systems I've checked use an alignment of 4, but some
1311 systems may use a different alignment. */
1312 rela_hdr
->sh_addralign
= 4;
1317 if (asect
->flags
& SEC_ALLOC
)
1319 this_hdr
->sh_flags
|= SHF_ALLOC
;
1320 if (asect
->flags
& SEC_LOAD
)
1322 /* @@ Do something with sh_type? */
1325 if (!(asect
->flags
& SEC_READONLY
))
1326 this_hdr
->sh_flags
|= SHF_WRITE
;
1327 if (asect
->flags
& SEC_CODE
)
1328 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1331 /* Map symbol from it's internal number to the external number, moving
1332 all local symbols to be at the head of the list. */
1335 sym_is_global (abfd
, sym
)
1339 /* If the backend has a special mapping, use it. */
1340 if (get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1341 return ((*get_elf_backend_data (abfd
)->elf_backend_sym_is_global
)
1344 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1346 if (sym
->flags
& BSF_LOCAL
)
1350 if (sym
->section
== 0)
1352 /* Is this valid? */
1357 if (sym
->section
== &bfd_und_section
)
1359 if (bfd_is_com_section (sym
->section
))
1361 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1367 DEFUN (elf_map_symbols
, (abfd
), bfd
* abfd
)
1369 int symcount
= bfd_get_symcount (abfd
);
1370 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1371 asymbol
**sect_syms
;
1373 int num_globals
= 0;
1374 int num_locals2
= 0;
1375 int num_globals2
= 0;
1377 int num_sections
= 0;
1378 Elf_Sym_Extra
*sym_extra
;
1383 fprintf (stderr
, "elf_map_symbols\n");
1387 /* Add local symbols for each section for which there are relocs.
1388 FIXME: How can we tell which sections have relocs at this point?
1389 Will reloc_count always be accurate? Actually, I think most ELF
1390 targets create section symbols for all sections anyhow. */
1391 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1393 if (max_index
< asect
->index
)
1394 max_index
= asect
->index
;
1398 elf_num_section_syms (abfd
) = max_index
;
1399 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1400 elf_section_syms (abfd
) = sect_syms
;
1402 BFD_ASSERT (sect_syms
!= 0);
1404 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1406 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1407 sym
->the_bfd
= abfd
;
1408 sym
->name
= asect
->name
;
1409 sym
->value
= asect
->vma
;
1410 sym
->flags
= BSF_SECTION_SYM
;
1411 sym
->section
= asect
;
1412 sect_syms
[asect
->index
] = sym
;
1416 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1417 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1424 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1425 ((symcount
+ num_sections
+ 1)
1426 * sizeof (asymbol
*)));
1428 syms
= (asymbol
**) bfd_alloc (abfd
,
1429 (num_sections
+ 1) * sizeof (asymbol
*));
1431 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1433 if (sect_syms
[asect
->index
])
1434 syms
[symcount
++] = sect_syms
[asect
->index
];
1437 syms
[symcount
] = (asymbol
*) 0;
1438 bfd_set_symtab (abfd
, syms
, symcount
);
1441 elf_sym_extra (abfd
) = sym_extra
1442 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1444 /* Identify and classify all of the symbols. */
1445 for (idx
= 0; idx
< symcount
; idx
++)
1447 if (!sym_is_global (abfd
, syms
[idx
]))
1453 /* Now provide mapping information. Add +1 for skipping over the
1455 for (idx
= 0; idx
< symcount
; idx
++)
1457 syms
[idx
]->udata
= (PTR
) &sym_extra
[idx
];
1458 if (!sym_is_global (abfd
, syms
[idx
]))
1459 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1461 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1464 elf_num_locals (abfd
) = num_locals
;
1465 elf_num_globals (abfd
) = num_globals
;
1468 static void assign_section_numbers ();
1469 static void assign_file_positions_except_relocs ();
1472 DEFUN (elf_compute_section_file_positions
, (abfd
), bfd
* abfd
)
1474 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1476 assign_section_numbers (abfd
);
1478 bfd_map_over_sections (abfd
, elf_make_sections
, 0);
1480 bfd_map_over_sections (abfd
, fix_up_strtabs
, 0); /* .stab/.stabstr &c */
1482 swap_out_syms (abfd
);
1484 assign_file_positions_except_relocs (abfd
);
1490 DEFUN (elf_write_phdrs
, (abfd
, i_ehdrp
, i_phdrp
, phdr_cnt
),
1492 Elf_Internal_Ehdr
* i_ehdrp AND
1493 Elf_Internal_Phdr
* i_phdrp AND
1494 Elf32_Half phdr_cnt
)
1496 /* first program header entry goes after the file header */
1497 int outbase
= i_ehdrp
->e_phoff
;
1499 Elf_External_Phdr x_phdr
;
1501 for (i
= 0; i
< phdr_cnt
; i
++)
1503 elf_swap_phdr_out (abfd
, i_phdrp
+ i
, &x_phdr
);
1504 bfd_seek (abfd
, outbase
, SEEK_SET
);
1505 bfd_write ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
);
1506 outbase
+= sizeof (x_phdr
);
1512 static const Elf_Internal_Shdr null_shdr
;
1514 /* Assign all ELF section numbers. The dummy first section is handled here
1515 too. The link/info pointers for the standard section types are filled
1516 in here too, while we're at it. (Link pointers for .stab sections are
1517 not filled in here.) */
1519 assign_section_numbers (abfd
)
1522 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1524 int section_number
= 1;
1526 Elf_Internal_Shdr
**i_shdrp
;
1528 t
->shstrtab_hdr
.sh_size
= elf_shstrtab(abfd
)->length
;
1529 t
->shstrtab_hdr
.contents
= (void *) elf_shstrtab(abfd
)->tab
;
1530 shstrtab_length_fixed
= 1;
1532 t
->shstrtab_section
= section_number
++;
1533 elf_elfheader(abfd
)->e_shstrndx
= t
->shstrtab_section
;
1536 t
->symtab_section
= section_number
++;
1537 t
->strtab_section
= section_number
++;
1538 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1540 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1542 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1543 d
->this_idx
= section_number
++;
1544 if (sec
->flags
& SEC_RELOC
)
1546 d
->rel_idx
= section_number
++;
1547 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1548 d
->rel_hdr
.sh_info
= d
->this_idx
;
1552 /* No handling for per-section string tables currently. */
1554 elf_elfheader(abfd
)->e_shnum
= section_number
;
1556 /* Set up the list of section header pointers, in agreement with the
1558 i_shdrp
= (Elf_Internal_Shdr
**)
1559 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*));
1560 elf_elfsections(abfd
) = i_shdrp
;
1561 for (i
= 0; i
< section_number
; i
++)
1564 i_shdrp
[0] = (Elf_Internal_Shdr
*) &null_shdr
;
1565 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1568 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1569 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1571 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1573 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1574 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1576 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1578 /* Make sure we got everything.... */
1579 for (i
= 0; i
< section_number
; i
++)
1580 if (i_shdrp
[i
] == 0)
1584 static INLINE file_ptr
1585 assign_file_position_for_section (i_shdrp
, offset
)
1586 Elf_Internal_Shdr
*i_shdrp
;
1591 if (i_shdrp
->sh_addralign
!= 0)
1592 align
= i_shdrp
->sh_addralign
;
1595 i_shdrp
->sh_offset
= offset
= BFD_ALIGN (offset
, align
);
1596 if (i_shdrp
->rawdata
!= NULL
)
1597 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1598 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1599 offset
+= i_shdrp
->sh_size
;
1603 static INLINE file_ptr
1604 align_file_position (off
)
1607 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1610 static INLINE file_ptr
1611 assign_file_positions_for_symtab_and_strtabs (abfd
, off
)
1615 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1617 off
= align_file_position (off
);
1618 off
= assign_file_position_for_section (&t
->symtab_hdr
, off
);
1619 off
= assign_file_position_for_section (&t
->shstrtab_hdr
, off
);
1620 off
= assign_file_position_for_section (&t
->strtab_hdr
, off
);
1625 bfd_vma low
, mem_size
;
1629 struct seg_info
*next
;
1633 map_program_segments (abfd
)
1636 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1637 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1638 Elf_Internal_Shdr
*i_shdrp
;
1639 Elf_Internal_Phdr
*phdr
;
1642 file_ptr lowest_offset
= 0;
1643 struct seg_info
*seg
= 0;
1645 done
= (char *) alloca (i_ehdrp
->e_shnum
);
1646 memset (done
, 0, i_ehdrp
->e_shnum
);
1647 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1649 i_shdrp
= i_shdrpp
[i
];
1650 /* If it's going to be mapped in, it's been assigned a position. */
1651 if (i_shdrp
->sh_offset
+ 1 == 0)
1653 /* Well, not really, but we won't process it here. */
1657 if (i_shdrp
->sh_offset
< lowest_offset
1658 || lowest_offset
== 0)
1659 lowest_offset
= i_shdrp
->sh_offset
;
1660 /* Only interested in PROGBITS or NOBITS for generating segments. */
1661 switch (i_shdrp
->sh_type
)
1674 bfd_vma lowest_vma
= -1, high
;
1679 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1681 i_shdrp
= i_shdrpp
[i
];
1682 if (!done
[i
] && i_shdrp
->sh_addr
< lowest_vma
)
1684 lowest_vma
= i_shdrp
->sh_addr
;
1690 /* So now we know the lowest vma of any unassigned sections; start
1694 s
= (struct seg_info
*) bfd_alloc (abfd
, sizeof (struct seg_info
));
1698 seg
->low
= lowest_vma
;
1699 i_shdrp
= i_shdrpp
[low_sec
];
1700 seg
->start_pos
= i_shdrp
->sh_offset
;
1701 seg
->sh_flags
= i_shdrp
->sh_flags
;
1702 done
[low_sec
] = 1, n_left
--;
1703 mem_size
= i_shdrp
->sh_size
;
1704 high
= lowest_vma
+ i_shdrp
->sh_size
;
1706 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1707 file_size
= i_shdrp
->sh_size
;
1709 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1713 if (file_size
!= mem_size
)
1717 i_shdrp
= i_shdrpp
[i
];
1718 /* position of next byte on disk */
1719 f1
= seg
->start_pos
+ file_size
;
1720 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1722 if (i_shdrp
->sh_offset
- f1
!= i_shdrp
->sh_addr
- high
)
1725 else /* sh_type == NOBITS */
1727 /* If the section in question has no contents in the disk
1728 file, we really don't care where it supposedly starts.
1729 But we don't want to bother merging it into this segment
1730 if it doesn't start on this memory page. */
1731 bfd_vma page1
, page2
;
1732 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1734 /* page number in address space of current end of seg */
1735 page1
= (high
- 1 + maxpagesize
- 1) / maxpagesize
;
1736 /* page number in address space of start of this section */
1737 page2
= (i_shdrp
->sh_addr
+ maxpagesize
- 1) / maxpagesize
;
1742 done
[i
] = 1, n_left
--;
1743 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1744 file_size
= i_shdrp
->sh_offset
+ i_shdrp
->sh_size
- seg
->start_pos
;
1745 mem_size
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
- seg
->low
;
1746 high
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
;
1749 seg
->file_size
= file_size
;
1750 seg
->mem_size
= mem_size
;
1752 /* Now do something with the list of segments we've built up. */
1754 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1759 for (s
= seg
; s
; s
= s
->next
)
1763 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1764 sz
= sizeof (Elf_External_Phdr
) * n_segs
;
1765 if (align_file_position (i_ehdrp
->e_ehsize
) + sz
<= lowest_offset
)
1766 i_ehdrp
->e_phoff
= align_file_position (i_ehdrp
->e_ehsize
);
1769 i_ehdrp
->e_phoff
= align_file_position (elf_tdata (abfd
)->next_file_pos
);
1770 elf_tdata (abfd
)->next_file_pos
= i_ehdrp
->e_phoff
+ sz
;
1772 phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
,
1773 n_segs
* sizeof (Elf_Internal_Phdr
));
1774 elf_tdata (abfd
)->phdr
= phdr
;
1777 phdr
->p_type
= PT_LOAD
; /* only type we really support so far */
1778 phdr
->p_offset
= seg
->start_pos
;
1779 phdr
->p_vaddr
= seg
->low
;
1781 phdr
->p_filesz
= seg
->file_size
;
1782 phdr
->p_memsz
= seg
->mem_size
;
1783 phdr
->p_flags
= PF_R
;
1784 phdr
->p_align
= maxpagesize
; /* ? */
1785 if (seg
->sh_flags
& SHF_WRITE
)
1786 /* SysVr4 ELF docs say "data segments normally have read, write,
1787 and execute permissions." */
1788 phdr
->p_flags
|= (PF_W
| PF_X
);
1789 if (seg
->sh_flags
& SHF_EXECINSTR
)
1790 phdr
->p_flags
|= PF_X
;
1794 i_ehdrp
->e_phnum
= n_segs
;
1796 elf_write_phdrs (abfd
, i_ehdrp
, elf_tdata (abfd
)->phdr
, i_ehdrp
->e_phnum
);
1800 assign_file_positions_except_relocs (abfd
)
1803 /* For now, we ignore the possibility of having program segments, which
1804 may require some alignment in the file. That'll require padding, and
1805 some interesting calculations to optimize file space usage.
1807 Also, since the application may change the list of relocations for
1808 a given section, we don't figure them in here. We'll put them at the
1809 end of the file, at positions computed during bfd_close.
1811 The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
1812 or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
1814 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1817 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1818 Elf_Internal_Shdr
*i_shdrp
;
1819 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1820 int exec_p
= (abfd
->flags
& EXEC_P
) != 0;
1822 /* Everything starts after the ELF file header. */
1823 off
= i_ehdrp
->e_ehsize
;
1827 /* Section headers. */
1828 off
= align_file_position (off
);
1829 i_ehdrp
->e_shoff
= off
;
1830 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1831 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1833 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1835 /* The symtab and strtab sections are placed by
1836 assign_file_positions_for_symtab_and_strtabs. */
1837 if (i
== t
->symtab_section
1838 || i
== t
->strtab_section
1839 || i
== t
->shstrtab_section
)
1842 i_shdrp
= i_shdrpp
[i
];
1843 if (i_shdrp
->sh_type
== SHT_REL
|| i_shdrp
->sh_type
== SHT_RELA
)
1845 i_shdrp
->sh_offset
= -1;
1850 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1851 if (maxpagesize
== 0)
1852 maxpagesize
= 1; /* make the arithmetic work */
1853 /* This isn't necessarily going to give the best packing, if the
1854 segments require padding between them, but since that isn't
1855 usually the case, this'll do. */
1856 if ((i_shdrp
->sh_flags
& SHF_ALLOC
) == 0)
1858 i_shdrp
->sh_offset
= -1;
1861 /* Blindly assume that the segments are ordered optimally. With
1862 the default LD script, they will be. */
1864 /* need big unsigned type */
1866 addtl_off
= i_shdrp
->sh_addr
- off
;
1867 addtl_off
= addtl_off
% maxpagesize
;
1873 if (i_shdrp
->sh_type
== SHT_NOBITS
)
1876 i_shdrp
->sh_offset
= off
;
1877 if (off
% maxpagesize
!= 0)
1878 off2
= maxpagesize
- (off
% maxpagesize
);
1879 if (off2
> i_shdrp
->sh_size
)
1880 off2
= i_shdrp
->sh_size
;
1884 off
= assign_file_position_for_section (i_shdrp
, off
);
1887 && get_elf_backend_data(abfd
)->maxpagesize
> 1
1888 && i_shdrp
->sh_type
== SHT_PROGBITS
1889 && (i_shdrp
->sh_flags
& SHF_ALLOC
)
1890 && (i_shdrp
->sh_offset
- i_shdrp
->sh_addr
) % get_elf_backend_data (abfd
)->maxpagesize
!= 0)
1895 elf_tdata (abfd
)->next_file_pos
= off
;
1896 map_program_segments (abfd
);
1897 off
= elf_tdata (abfd
)->next_file_pos
;
1899 /* Section headers. */
1900 off
= align_file_position (off
);
1901 i_ehdrp
->e_shoff
= off
;
1902 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1904 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1906 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1908 i_shdrp
= i_shdrpp
[i
];
1909 if (i_shdrp
->sh_offset
+ 1 == 0
1910 && i_shdrp
->sh_type
!= SHT_REL
1911 && i_shdrp
->sh_type
!= SHT_RELA
)
1912 off
= assign_file_position_for_section (i_shdrp
, off
);
1915 elf_tdata (abfd
)->next_file_pos
= off
;
1922 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1923 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
1924 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1926 struct strtab
*shstrtab
;
1928 i_ehdrp
= elf_elfheader (abfd
);
1929 i_shdrp
= elf_elfsections (abfd
);
1931 shstrtab
= bfd_new_strtab (abfd
);
1932 elf_shstrtab (abfd
) = shstrtab
;
1934 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
1935 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
1936 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
1937 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
1939 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
1940 i_ehdrp
->e_ident
[EI_DATA
] =
1941 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
1942 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1944 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
1945 i_ehdrp
->e_ident
[count
] = 0;
1947 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
1948 switch (bfd_get_arch (abfd
))
1950 case bfd_arch_unknown
:
1951 i_ehdrp
->e_machine
= EM_NONE
;
1953 case bfd_arch_sparc
:
1954 i_ehdrp
->e_machine
= EM_SPARC
;
1955 /* start-sanitize-v9 */
1957 i_ehdrp
->e_machine
= EM_SPARC64
;
1959 /* end-sanitize-v9 */
1962 i_ehdrp
->e_machine
= EM_386
;
1965 i_ehdrp
->e_machine
= EM_68K
;
1968 i_ehdrp
->e_machine
= EM_88K
;
1971 i_ehdrp
->e_machine
= EM_860
;
1973 case bfd_arch_mips
: /* MIPS Rxxxx */
1974 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
1977 i_ehdrp
->e_machine
= EM_HPPA
;
1979 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
1981 i_ehdrp
->e_machine
= EM_NONE
;
1983 i_ehdrp
->e_version
= EV_CURRENT
;
1984 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
1986 /* no program header, for now. */
1987 i_ehdrp
->e_phoff
= 0;
1988 i_ehdrp
->e_phentsize
= 0;
1989 i_ehdrp
->e_phnum
= 0;
1991 /* each bfd section is section header entry */
1992 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
1993 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
1995 /* if we're building an executable, we'll need a program header table */
1996 if (abfd
->flags
& EXEC_P
)
1998 /* it all happens later */
2000 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2002 /* elf_build_phdrs() returns a (NULL-terminated) array of
2003 Elf_Internal_Phdrs */
2004 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2005 i_ehdrp
->e_phoff
= outbase
;
2006 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2011 i_ehdrp
->e_phentsize
= 0;
2013 i_ehdrp
->e_phoff
= 0;
2016 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2018 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2020 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
2026 swap_out_syms (abfd
)
2029 elf_map_symbols (abfd
);
2031 /* Dump out the symtabs. */
2033 int symcount
= bfd_get_symcount (abfd
);
2034 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2035 struct strtab
*stt
= bfd_new_strtab (abfd
);
2036 Elf_Internal_Shdr
*symtab_hdr
;
2037 Elf_Internal_Shdr
*symstrtab_hdr
;
2038 Elf_External_Sym
*outbound_syms
;
2041 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2042 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2043 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2044 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2045 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2047 /* FIXME: Systems I've checked use 4 byte alignment for .symtab,
2048 but it is possible that there are systems which use a different
2050 symtab_hdr
->sh_addralign
= 4;
2052 /* see assert in elf_fake_sections that supports this: */
2053 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2054 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2056 outbound_syms
= (Elf_External_Sym
*)
2057 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2058 /* now generate the data (for "contents") */
2060 /* Fill in zeroth symbol and swap it out. */
2061 Elf_Internal_Sym sym
;
2067 sym
.st_shndx
= SHN_UNDEF
;
2068 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2070 for (idx
= 0; idx
< symcount
; idx
++)
2072 Elf_Internal_Sym sym
;
2073 bfd_vma value
= syms
[idx
]->value
;
2075 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2076 /* Section symbols have no names. */
2079 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2081 if (bfd_is_com_section (syms
[idx
]->section
))
2083 /* ELF common symbols put the alignment into the `value' field,
2084 and the size into the `size' field. This is backwards from
2085 how BFD handles it, so reverse it here. */
2086 sym
.st_size
= value
;
2087 /* Should retrieve this from somewhere... */
2089 sym
.st_shndx
= SHN_COMMON
;
2093 asection
*sec
= syms
[idx
]->section
;
2094 elf_symbol_type
*type_ptr
;
2097 if (sec
->output_section
)
2099 value
+= sec
->output_offset
;
2100 sec
= sec
->output_section
;
2103 sym
.st_value
= value
;
2104 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2105 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2106 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2110 /* Writing this would be a hell of a lot easier if we had
2111 some decent documentation on bfd, and knew what to expect
2112 of the library, and what to demand of applications. For
2113 example, it appears that `objcopy' might not set the
2114 section of a symbol to be a section that is actually in
2116 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2118 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2119 assert (shndx
!= -1);
2123 if (bfd_is_com_section (syms
[idx
]->section
))
2124 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2125 else if (syms
[idx
]->section
== &bfd_und_section
)
2126 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2127 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2128 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2129 else if (syms
[idx
]->flags
& BSF_FILE
)
2130 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2133 int bind
= STB_LOCAL
;
2134 int type
= STT_OBJECT
;
2135 unsigned int flags
= syms
[idx
]->flags
;
2137 if (flags
& BSF_LOCAL
)
2139 else if (flags
& BSF_WEAK
)
2141 else if (flags
& BSF_GLOBAL
)
2144 if (flags
& BSF_FUNCTION
)
2147 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2151 elf_swap_symbol_out (abfd
, &sym
,
2153 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2156 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2157 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2158 symstrtab_hdr
->sh_size
= stt
->length
;
2159 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2161 symstrtab_hdr
->sh_flags
= 0;
2162 symstrtab_hdr
->sh_addr
= 0;
2163 symstrtab_hdr
->sh_entsize
= 0;
2164 symstrtab_hdr
->sh_link
= 0;
2165 symstrtab_hdr
->sh_info
= 0;
2166 symstrtab_hdr
->sh_addralign
= 1;
2167 symstrtab_hdr
->size
= 0;
2170 /* put the strtab out too... */
2172 Elf_Internal_Shdr
*this_hdr
;
2174 this_hdr
= &elf_tdata(abfd
)->shstrtab_hdr
;
2175 this_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
2176 this_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
2177 this_hdr
->sh_type
= SHT_STRTAB
;
2178 this_hdr
->sh_flags
= 0;
2179 this_hdr
->sh_addr
= 0;
2180 this_hdr
->sh_entsize
= 0;
2181 this_hdr
->sh_addralign
= 1;
2187 write_shdrs_and_ehdr (abfd
)
2190 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2191 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2192 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2193 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2195 struct strtab
*shstrtab
;
2197 i_ehdrp
= elf_elfheader (abfd
);
2198 i_shdrp
= elf_elfsections (abfd
);
2199 shstrtab
= elf_shstrtab (abfd
);
2201 /* swap the header before spitting it out... */
2204 elf_debug_file (i_ehdrp
);
2206 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2207 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
2208 bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
);
2210 /* at this point we've concocted all the ELF sections... */
2211 x_shdrp
= (Elf_External_Shdr
*)
2212 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2215 bfd_error
= no_memory
;
2219 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2222 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2225 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2227 bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
);
2228 bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
);
2229 /* need to dump the string table too... */
2235 assign_file_positions_for_relocs (abfd
)
2238 file_ptr off
= elf_tdata(abfd
)->next_file_pos
;
2240 Elf_Internal_Shdr
**shdrpp
= elf_elfsections (abfd
);
2241 Elf_Internal_Shdr
*shdrp
;
2242 for (i
= 1; i
< elf_elfheader(abfd
)->e_shnum
; i
++)
2245 if (shdrp
->sh_type
!= SHT_REL
&& shdrp
->sh_type
!= SHT_RELA
)
2247 off
= align_file_position (off
);
2248 off
= assign_file_position_for_section (shdrp
, off
);
2250 elf_tdata(abfd
)->next_file_pos
= off
;
2254 DEFUN (NAME(bfd_elf
,write_object_contents
), (abfd
), bfd
* abfd
)
2256 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2257 Elf_Internal_Ehdr
*i_ehdrp
;
2258 Elf_Internal_Shdr
**i_shdrp
;
2261 if (abfd
->output_has_begun
== false)
2263 prep_headers (abfd
);
2264 elf_compute_section_file_positions (abfd
);
2265 abfd
->output_has_begun
= true;
2268 i_shdrp
= elf_elfsections (abfd
);
2269 i_ehdrp
= elf_elfheader (abfd
);
2271 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2272 assign_file_positions_for_relocs (abfd
);
2274 /* After writing the headers, we need to write the sections too... */
2275 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2277 if (bed
->elf_backend_section_processing
)
2278 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2279 if (i_shdrp
[count
]->contents
)
2281 bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
);
2282 bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
, 1,
2287 if (bed
->elf_backend_final_write_processing
)
2288 (*bed
->elf_backend_final_write_processing
) (abfd
);
2290 return write_shdrs_and_ehdr (abfd
);
2293 /* Given an index of a section, retrieve a pointer to it. Note
2294 that for our purposes, sections are indexed by {1, 2, ...} with
2295 0 being an illegal index. */
2297 /* In the original, each ELF section went into exactly one BFD
2298 section. This doesn't really make sense, so we need a real mapping.
2299 The mapping has to hide in the Elf_Internal_Shdr since asection
2300 doesn't have anything like a tdata field... */
2303 DEFUN (section_from_elf_index
, (abfd
, index
),
2307 /* @@ Is bfd_com_section really correct in all the places it could
2308 be returned from this routine? */
2310 if (index
== SHN_ABS
)
2311 return &bfd_com_section
; /* not abs? */
2312 if (index
== SHN_COMMON
)
2313 return &bfd_com_section
;
2315 if (index
> elf_elfheader (abfd
)->e_shnum
)
2319 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2321 switch (hdr
->sh_type
)
2323 /* ELF sections that map to BFD sections */
2327 bfd_section_from_shdr (abfd
, index
);
2328 return (struct sec
*) hdr
->rawdata
;
2331 return (struct sec
*) &bfd_abs_section
;
2336 /* given a section, search the header to find them... */
2338 DEFUN (elf_section_from_bfd_section
, (abfd
, asect
),
2342 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2344 Elf_Internal_Shdr
*hdr
;
2345 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2347 if (asect
== &bfd_abs_section
)
2349 if (asect
== &bfd_com_section
)
2351 if (asect
== &bfd_und_section
)
2354 for (index
= 0; index
< maxindex
; index
++)
2356 hdr
= i_shdrp
[index
];
2357 switch (hdr
->sh_type
)
2359 /* ELF sections that map to BFD sections */
2365 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2371 /* fix_up_strtabs will generate STRTAB sections with names
2373 if (!strncmp (asect
->name
, ".stab", 5)
2374 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
2378 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2386 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2388 if (bed
->elf_backend_section_from_bfd_section
)
2393 if ((*bed
->elf_backend_section_from_bfd_section
)
2394 (abfd
, hdr
, asect
, &retval
))
2404 /* given a symbol, return the bfd index for that symbol. */
2406 DEFUN (elf_symbol_from_bfd_symbol
, (abfd
, asym_ptr_ptr
),
2408 struct symbol_cache_entry
**asym_ptr_ptr
)
2410 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2412 flagword flags
= asym_ptr
->flags
;
2414 /* When gas creates relocations against local labels, it creates its
2415 own symbol for the section, but does put the symbol into the
2416 symbol chain, so udata is 0. When the linker is generating
2417 relocatable output, this section symbol may be for one of the
2418 input sections rather than the output section. */
2419 if (asym_ptr
->udata
== (PTR
) 0
2420 && (flags
& BSF_SECTION_SYM
)
2421 && asym_ptr
->section
)
2425 if (asym_ptr
->section
->output_section
!= NULL
)
2426 indx
= asym_ptr
->section
->output_section
->index
;
2428 indx
= asym_ptr
->section
->index
;
2429 if (elf_section_syms (abfd
)[indx
])
2430 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2433 if (asym_ptr
->udata
)
2434 idx
= ((Elf_Sym_Extra
*)asym_ptr
->udata
)->elf_sym_num
;
2444 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2445 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2454 DEFUN (elf_slurp_symbol_table
, (abfd
, symptrs
),
2456 asymbol
** symptrs
) /* Buffer for generated bfd symbols */
2458 Elf_Internal_Shdr
*hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2459 int symcount
; /* Number of external ELF symbols */
2461 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2462 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2463 Elf_Internal_Sym i_sym
;
2464 Elf_External_Sym
*x_symp
;
2466 /* this is only valid because there is only one symtab... */
2467 /* FIXME: This is incorrect, there may also be a dynamic symbol
2468 table which is a subset of the full symbol table. We either need
2469 to be prepared to read both (and merge them) or ensure that we
2470 only read the full symbol table. Currently we only get called to
2471 read the full symbol table. -fnf */
2472 if (bfd_get_outsymbols (abfd
) != NULL
)
2477 /* Read each raw ELF symbol, converting from external ELF form to
2478 internal ELF form, and then using the information to create a
2479 canonical bfd symbol table entry.
2481 Note that we allocate the initial bfd canonical symbol buffer
2482 based on a one-to-one mapping of the ELF symbols to canonical
2483 symbols. We actually use all the ELF symbols, so there will be no
2484 space left over at the end. When we have all the symbols, we
2485 build the caller's pointer vector. */
2487 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2489 bfd_error
= system_call_error
;
2493 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2494 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
));
2497 /* Temporarily allocate room for the raw ELF symbols. */
2498 x_symp
= (Elf_External_Sym
*) bfd_xmalloc (symcount
* sizeof (Elf_External_Sym
));
2500 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2501 != symcount
* sizeof (Elf_External_Sym
))
2503 free ((PTR
) x_symp
);
2504 bfd_error
= system_call_error
;
2507 /* Skip first symbol, which is a null dummy. */
2508 for (i
= 1; i
< symcount
; i
++)
2510 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2511 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2512 #ifdef ELF_KEEP_EXTSYM
2513 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2515 sym
->symbol
.the_bfd
= abfd
;
2517 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2520 sym
->symbol
.value
= i_sym
.st_value
;
2522 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
2524 sym
->symbol
.section
= section_from_elf_index (abfd
, i_sym
.st_shndx
);
2526 else if (i_sym
.st_shndx
== SHN_ABS
)
2528 sym
->symbol
.section
= &bfd_abs_section
;
2530 else if (i_sym
.st_shndx
== SHN_COMMON
)
2532 sym
->symbol
.section
= &bfd_com_section
;
2533 /* Elf puts the alignment into the `value' field, and the size
2534 into the `size' field. BFD wants to see the size in the
2535 value field, and doesn't care (at the moment) about the
2537 sym
->symbol
.value
= i_sym
.st_size
;
2539 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2541 sym
->symbol
.section
= &bfd_und_section
;
2544 sym
->symbol
.section
= &bfd_abs_section
;
2546 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2548 switch (ELF_ST_BIND (i_sym
.st_info
))
2551 sym
->symbol
.flags
|= BSF_LOCAL
;
2554 sym
->symbol
.flags
|= BSF_GLOBAL
;
2557 sym
->symbol
.flags
|= BSF_WEAK
;
2561 switch (ELF_ST_TYPE (i_sym
.st_info
))
2564 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2567 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2570 sym
->symbol
.flags
|= BSF_FUNCTION
;
2574 /* Do some backend-specific processing on this symbol. */
2576 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2577 if (ebd
->elf_backend_symbol_processing
)
2578 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2584 /* Do some backend-specific processing on this symbol table. */
2586 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2587 if (ebd
->elf_backend_symbol_table_processing
)
2588 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2591 /* We rely on the zalloc to clear out the final symbol entry. */
2593 bfd_get_symcount (abfd
) = symcount
= sym
- symbase
;
2595 /* Fill in the user's symbol pointer vector if needed. */
2599 while (symcount
-- > 0)
2601 *symptrs
++ = &sym
->symbol
;
2604 *symptrs
= 0; /* Final null pointer */
2610 /* Return the number of bytes required to hold the symtab vector.
2612 Note that we base it on the count plus 1, since we will null terminate
2613 the vector allocated based on this size. However, the ELF symbol table
2614 always has a dummy entry as symbol #0, so it ends up even. */
2617 DEFUN (elf_get_symtab_upper_bound
, (abfd
), bfd
* abfd
)
2619 unsigned int symcount
;
2620 unsigned int symtab_size
= 0;
2622 Elf_Internal_Shdr
*hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2623 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2624 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
));
2630 This function return the number of bytes required to store the
2631 relocation information associated with section <<sect>>
2632 attached to bfd <<abfd>>
2636 elf_get_reloc_upper_bound (abfd
, asect
)
2640 if (asect
->flags
& SEC_RELOC
)
2642 /* either rel or rela */
2643 return elf_section_data(asect
)->rel_hdr
.sh_size
;
2650 DEFUN (elf_slurp_reloca_table
, (abfd
, asect
, symbols
),
2655 Elf_External_Rela
*native_relocs
;
2656 arelent
*reloc_cache
;
2661 if (asect
->relocation
)
2663 if (asect
->reloc_count
== 0)
2665 if (asect
->flags
& SEC_CONSTRUCTOR
)
2668 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2669 native_relocs
= (Elf_External_Rela
*)
2670 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2671 bfd_read ((PTR
) native_relocs
,
2672 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
);
2674 reloc_cache
= (arelent
*)
2675 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2679 bfd_error
= no_memory
;
2683 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2685 Elf_Internal_Rela dst
;
2686 Elf_External_Rela
*src
;
2688 cache_ptr
= reloc_cache
+ idx
;
2689 src
= native_relocs
+ idx
;
2690 elf_swap_reloca_in (abfd
, src
, &dst
);
2692 #ifdef RELOC_PROCESSING
2693 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2695 if (asect
->flags
& SEC_RELOC
)
2697 /* relocatable, so the offset is off of the section */
2698 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2702 /* non-relocatable, so the offset a virtual address */
2703 cache_ptr
->address
= dst
.r_offset
;
2706 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2707 of zero points to the dummy symbol, which was not read into
2708 the symbol table SYMBOLS. */
2709 if (ELF_R_SYM (dst
.r_info
) == 0)
2710 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2715 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2717 /* Translate any ELF section symbol into a BFD section
2719 s
= *(cache_ptr
->sym_ptr_ptr
);
2720 if (s
->flags
& BSF_SECTION_SYM
)
2722 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2723 s
= *cache_ptr
->sym_ptr_ptr
;
2724 if (s
->name
== 0 || s
->name
[0] == 0)
2728 cache_ptr
->addend
= dst
.r_addend
;
2730 /* Fill in the cache_ptr->howto field from dst.r_type */
2732 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2733 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2738 asect
->relocation
= reloc_cache
;
2744 elf_debug_section (str
, num
, hdr
)
2747 Elf_Internal_Shdr
*hdr
;
2749 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
2751 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
2752 (long) hdr
->sh_name
,
2753 (long) hdr
->sh_type
,
2754 (long) hdr
->sh_flags
);
2756 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
2757 (long) hdr
->sh_addr
,
2758 (long) hdr
->sh_offset
,
2759 (long) hdr
->sh_size
);
2761 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
2762 (long) hdr
->sh_link
,
2763 (long) hdr
->sh_info
,
2764 (long) hdr
->sh_addralign
);
2765 fprintf (stderr
, "sh_entsize = %ld\n",
2766 (long) hdr
->sh_entsize
);
2767 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
2768 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
2769 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
2774 elf_debug_file (ehdrp
)
2775 Elf_Internal_Ehdr
*ehdrp
;
2777 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
2778 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
2779 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
2780 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
2781 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
2782 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
2783 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
2788 DEFUN (elf_slurp_reloc_table
, (abfd
, asect
, symbols
),
2793 Elf_External_Rel
*native_relocs
;
2794 arelent
*reloc_cache
;
2796 Elf_Internal_Shdr
*data_hdr
;
2797 ElfNAME (Off
) data_off
;
2798 ElfNAME (Word
) data_max
;
2799 char buf
[4]; /* FIXME -- might be elf64 */
2803 if (asect
->relocation
)
2805 if (asect
->reloc_count
== 0)
2807 if (asect
->flags
& SEC_CONSTRUCTOR
)
2810 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2811 native_relocs
= (Elf_External_Rel
*)
2812 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
2813 bfd_read ((PTR
) native_relocs
,
2814 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
);
2816 reloc_cache
= (arelent
*)
2817 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2821 bfd_error
= no_memory
;
2825 /* Get the offset of the start of the segment we are relocating to read in
2826 the implicit addend. */
2827 data_hdr
= &elf_section_data(asect
)->this_hdr
;
2828 data_off
= data_hdr
->sh_offset
;
2829 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
2832 elf_debug_section ("data section", -1, data_hdr
);
2835 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2837 #ifdef RELOC_PROCESSING
2838 Elf_Internal_Rel dst
;
2839 Elf_External_Rel
*src
;
2841 cache_ptr
= reloc_cache
+ idx
;
2842 src
= native_relocs
+ idx
;
2843 elf_swap_reloc_in (abfd
, src
, &dst
);
2845 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2847 Elf_Internal_Rel dst
;
2848 Elf_External_Rel
*src
;
2850 cache_ptr
= reloc_cache
+ idx
;
2851 src
= native_relocs
+ idx
;
2853 elf_swap_reloc_in (abfd
, src
, &dst
);
2855 if (asect
->flags
& SEC_RELOC
)
2857 /* relocatable, so the offset is off of the section */
2858 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2862 /* non-relocatable, so the offset a virtual address */
2863 cache_ptr
->address
= dst
.r_offset
;
2866 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2867 of zero points to the dummy symbol, which was not read into
2868 the symbol table SYMBOLS. */
2869 if (ELF_R_SYM (dst
.r_info
) == 0)
2870 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2875 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2877 /* Translate any ELF section symbol into a BFD section
2879 s
= *(cache_ptr
->sym_ptr_ptr
);
2880 if (s
->flags
& BSF_SECTION_SYM
)
2882 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2883 s
= *cache_ptr
->sym_ptr_ptr
;
2884 if (s
->name
== 0 || s
->name
[0] == 0)
2888 BFD_ASSERT (dst
.r_offset
<= data_max
);
2889 cache_ptr
->addend
= 0;
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_rel
) (abfd
, cache_ptr
, &dst
);
2899 asect
->relocation
= reloc_cache
;
2904 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2910 arelent
*tblptr
= section
->relocation
;
2911 unsigned int count
= 0;
2912 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
2914 /* snarfed from coffcode.h */
2916 elf_slurp_reloca_table (abfd
, section
, symbols
);
2918 elf_slurp_reloc_table (abfd
, section
, symbols
);
2920 tblptr
= section
->relocation
;
2924 for (; count
++ < section
->reloc_count
;)
2925 *relptr
++ = tblptr
++;
2928 return section
->reloc_count
;
2932 DEFUN (elf_get_symtab
, (abfd
, alocation
),
2934 asymbol
** alocation
)
2937 if (!elf_slurp_symbol_table (abfd
, alocation
))
2940 return bfd_get_symcount (abfd
);
2944 DEFUN (elf_make_empty_symbol
, (abfd
),
2947 elf_symbol_type
*newsym
;
2949 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
2952 bfd_error
= no_memory
;
2957 newsym
->symbol
.the_bfd
= abfd
;
2958 return &newsym
->symbol
;
2963 DEFUN (elf_get_symbol_info
, (ignore_abfd
, symbol
, ret
),
2964 bfd
* ignore_abfd AND
2965 asymbol
* symbol AND
2968 bfd_symbol_info (symbol
, ret
);
2972 DEFUN (elf_print_symbol
, (ignore_abfd
, filep
, symbol
, how
),
2973 bfd
* ignore_abfd AND
2975 asymbol
* symbol AND
2976 bfd_print_symbol_type how
)
2978 FILE *file
= (FILE *) filep
;
2981 case bfd_print_symbol_name
:
2982 fprintf (file
, "%s", symbol
->name
);
2984 case bfd_print_symbol_more
:
2985 fprintf (file
, "elf ");
2986 fprintf_vma (file
, symbol
->value
);
2987 fprintf (file
, " %lx", (long) symbol
->flags
);
2989 case bfd_print_symbol_all
:
2991 CONST
char *section_name
;
2992 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
2993 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
2994 fprintf (file
, " %s\t%s",
3004 DEFUN (elf_get_lineno
, (ignore_abfd
, symbol
),
3005 bfd
* ignore_abfd AND
3008 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3015 DEFUN (elf_set_arch_mach
, (abfd
, arch
, machine
),
3017 enum bfd_architecture arch AND
3018 unsigned long machine
)
3020 /* Allow any architecture to be supported by the elf backend */
3023 case bfd_arch_unknown
: /* EM_NONE */
3024 case bfd_arch_sparc
: /* EM_SPARC */
3025 case bfd_arch_i386
: /* EM_386 */
3026 case bfd_arch_m68k
: /* EM_68K */
3027 case bfd_arch_m88k
: /* EM_88K */
3028 case bfd_arch_i860
: /* EM_860 */
3029 case bfd_arch_mips
: /* EM_MIPS (MIPS R3000) */
3030 case bfd_arch_hppa
: /* EM_HPPA (HP PA_RISC) */
3031 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3038 DEFUN (elf_find_nearest_line
, (abfd
,
3046 asection
* section AND
3047 asymbol
** symbols AND
3049 CONST
char **filename_ptr AND
3050 CONST
char **functionname_ptr AND
3051 unsigned int *line_ptr
)
3057 DEFUN (elf_sizeof_headers
, (abfd
, reloc
),
3061 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
3068 DEFUN (elf_set_section_contents
, (abfd
, section
, location
, offset
, count
),
3073 bfd_size_type count
)
3075 Elf_Internal_Shdr
*hdr
;
3077 if (abfd
->output_has_begun
== false) /* set by bfd.c handler? */
3079 /* do setup calculations (FIXME) */
3080 prep_headers (abfd
);
3081 elf_compute_section_file_positions (abfd
);
3082 abfd
->output_has_begun
= true;
3085 hdr
= &elf_section_data(section
)->this_hdr
;
3087 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3089 if (bfd_write (location
, 1, count
, abfd
) != count
)
3096 DEFUN (elf_no_info_to_howto
, (abfd
, cache_ptr
, dst
),
3098 arelent
* cache_ptr AND
3099 Elf_Internal_Rela
* dst
)
3101 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3107 DEFUN (elf_no_info_to_howto_rel
, (abfd
, cache_ptr
, dst
),
3109 arelent
* cache_ptr AND
3110 Elf_Internal_Rel
* dst
)
3112 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3118 /* Core file support */
3120 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3121 #include <sys/procfs.h>
3123 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
3124 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
3125 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
3131 DEFUN (bfd_prstatus
, (abfd
, descdata
, descsz
, filepos
),
3138 prstatus_t
*status
= (prstatus_t
*) 0;
3140 if (descsz
== sizeof (prstatus_t
))
3142 newsect
= bfd_make_section (abfd
, ".reg");
3143 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3144 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3145 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3146 newsect
->alignment_power
= 2;
3147 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3149 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3154 /* Stash a copy of the prpsinfo structure away for future use. */
3157 DEFUN (bfd_prpsinfo
, (abfd
, descdata
, descsz
, filepos
),
3165 if (descsz
== sizeof (prpsinfo_t
))
3167 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3169 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3175 DEFUN (bfd_fpregset
, (abfd
, descdata
, descsz
, filepos
),
3183 newsect
= bfd_make_section (abfd
, ".reg2");
3184 newsect
->_raw_size
= descsz
;
3185 newsect
->filepos
= filepos
;
3186 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3187 newsect
->alignment_power
= 2;
3190 #endif /* HAVE_PROCFS */
3192 /* Return a pointer to the args (including the command name) that were
3193 seen by the program that generated the core dump. Note that for
3194 some reason, a spurious space is tacked onto the end of the args
3195 in some (at least one anyway) implementations, so strip it off if
3199 DEFUN (elf_core_file_failing_command
, (abfd
),
3203 if (core_prpsinfo (abfd
))
3205 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3206 char *scan
= p
->pr_psargs
;
3211 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3215 return p
->pr_psargs
;
3221 /* Return the number of the signal that caused the core dump. Presumably,
3222 since we have a core file, we got a signal of some kind, so don't bother
3223 checking the other process status fields, just return the signal number.
3227 DEFUN (elf_core_file_failing_signal
, (abfd
),
3231 if (core_prstatus (abfd
))
3233 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3239 /* Check to see if the core file could reasonably be expected to have
3240 come for the current executable file. Note that by default we return
3241 true unless we find something that indicates that there might be a
3246 DEFUN (elf_core_file_matches_executable_p
, (core_bfd
, exec_bfd
),
3255 /* First, xvecs must match since both are ELF files for the same target. */
3257 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3259 bfd_error
= system_call_error
;
3265 /* If no prpsinfo, just return true. Otherwise, grab the last component
3266 of the exec'd pathname from the prpsinfo. */
3268 if (core_prpsinfo (core_bfd
))
3270 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3277 /* Find the last component of the executable pathname. */
3279 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3285 execname
= (char *) exec_bfd
->filename
;
3288 /* See if they match */
3290 return strcmp (execname
, corename
) ? false : true;
3296 #endif /* HAVE_PROCFS */
3299 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3300 the information that would normally be available from the /proc interface
3301 for the process, at the time the process dumped core. Currently this
3302 includes copies of the prstatus, prpsinfo, and fpregset structures.
3304 Since these structures are potentially machine dependent in size and
3305 ordering, bfd provides two levels of support for them. The first level,
3306 available on all machines since it does not require that the host
3307 have /proc support or the relevant include files, is to create a bfd
3308 section for each of the prstatus, prpsinfo, and fpregset structures,
3309 without any interpretation of their contents. With just this support,
3310 the bfd client will have to interpret the structures itself. Even with
3311 /proc support, it might want these full structures for it's own reasons.
3313 In the second level of support, where HAVE_PROCFS is defined, bfd will
3314 pick apart the structures to gather some additional information that
3315 clients may want, such as the general register set, the name of the
3316 exec'ed file and its arguments, the signal (if any) that caused the
3322 DEFUN (elf_corefile_note
, (abfd
, hdr
),
3324 Elf_Internal_Phdr
* hdr
)
3326 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3327 Elf_Internal_Note i_note
; /* Elf note, internal form */
3328 char *buf
= NULL
; /* Entire note segment contents */
3329 char *namedata
; /* Name portion of the note */
3330 char *descdata
; /* Descriptor portion of the note */
3331 char *sectname
; /* Name to use for new section */
3332 long filepos
; /* File offset to descriptor data */
3335 if (hdr
->p_filesz
> 0
3336 && (buf
= (char *) bfd_xmalloc (hdr
->p_filesz
)) != NULL
3337 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3338 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3340 x_note_p
= (Elf_External_Note
*) buf
;
3341 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3343 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3344 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3345 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3346 namedata
= x_note_p
->name
;
3347 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3348 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3349 switch (i_note
.type
)
3352 /* process descdata as prstatus info */
3353 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
3354 sectname
= ".prstatus";
3357 /* process descdata as fpregset info */
3358 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
3359 sectname
= ".fpregset";
3362 /* process descdata as prpsinfo */
3363 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
3364 sectname
= ".prpsinfo";
3367 /* Unknown descriptor, just ignore it. */
3371 if (sectname
!= NULL
)
3373 newsect
= bfd_make_section (abfd
, sectname
);
3374 newsect
->_raw_size
= i_note
.descsz
;
3375 newsect
->filepos
= filepos
;
3376 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3377 newsect
->alignment_power
= 2;
3379 x_note_p
= (Elf_External_Note
*)
3380 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3391 /* Core files are simply standard ELF formatted files that partition
3392 the file using the execution view of the file (program header table)
3393 rather than the linking view. In fact, there is no section header
3394 table in a core file.
3396 The process status information (including the contents of the general
3397 register set) and the floating point register set are stored in a
3398 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3399 that allow standard bfd access to the general registers (.reg) and the
3400 floating point registers (.reg2).
3405 DEFUN (elf_core_file_p
, (abfd
), bfd
* abfd
)
3407 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3408 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3409 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3410 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3411 unsigned int phindex
;
3413 /* Read in the ELF header in external format. */
3415 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3417 bfd_error
= system_call_error
;
3421 /* Now check to see if we have a valid ELF file, and one that BFD can
3422 make use of. The magic number must match, the address size ('class')
3423 and byte-swapping must match our XVEC entry, and it must have a
3424 program header table (FIXME: See comments re segments at top of this
3427 if (elf_file_p (&x_ehdr
) == false)
3430 bfd_error
= wrong_format
;
3434 /* FIXME, Check EI_VERSION here ! */
3438 int desired_address_size
= ELFCLASS32
;
3441 int desired_address_size
= ELFCLASS64
;
3444 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3448 /* Switch xvec to match the specified byte order. */
3449 switch (x_ehdr
.e_ident
[EI_DATA
])
3451 case ELFDATA2MSB
: /* Big-endian */
3452 if (abfd
->xvec
->byteorder_big_p
== false)
3455 case ELFDATA2LSB
: /* Little-endian */
3456 if (abfd
->xvec
->byteorder_big_p
== true)
3459 case ELFDATANONE
: /* No data encoding specified */
3460 default: /* Unknown data encoding specified */
3464 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3465 the tdata pointer in the bfd. */
3468 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3469 if (elf_tdata (abfd
) == NULL
)
3471 bfd_error
= no_memory
;
3475 /* FIXME, `wrong' returns from this point onward, leak memory. */
3477 /* Now that we know the byte order, swap in the rest of the header */
3478 i_ehdrp
= elf_elfheader (abfd
);
3479 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3481 elf_debug_file (i_ehdrp
);
3484 /* If there is no program header, or the type is not a core file, then
3486 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3489 /* Allocate space for a copy of the program header table in
3490 internal form, seek to the program header table in the file,
3491 read it in, and convert it to internal form. As a simple sanity
3492 check, verify that the what BFD thinks is the size of each program
3493 header table entry actually matches the size recorded in the file. */
3495 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3497 i_phdrp
= (Elf_Internal_Phdr
*)
3498 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3501 bfd_error
= no_memory
;
3504 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3506 bfd_error
= system_call_error
;
3509 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3511 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3514 bfd_error
= system_call_error
;
3517 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3520 /* Once all of the program headers have been read and converted, we
3521 can start processing them. */
3523 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3525 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3526 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3528 elf_corefile_note (abfd
, i_phdrp
+ phindex
);
3532 /* Remember the entry point specified in the ELF file header. */
3534 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;