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
)
647 hdr2
= &elf_section_data (target_sect
)->rel_hdr
;
649 elf_elfsections(abfd
)[shindex
] = hdr2
;
650 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
651 target_sect
->flags
|= SEC_RELOC
;
652 target_sect
->relocation
= 0;
653 target_sect
->rel_filepos
= hdr
->sh_offset
;
654 abfd
->flags
|= HAS_RELOC
;
661 case SHT_DYNSYM
: /* could treat this like symtab... */
663 fprintf (stderr
, "Dynamic Linking sections not yet supported.\n");
670 fprintf (stderr
, "Note Sections not yet supported.\n");
677 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
682 /* Check for any processor-specific section types. */
684 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
686 if (bed
->elf_backend_section_from_shdr
)
687 (*bed
->elf_backend_section_from_shdr
) (abfd
, hdr
, name
);
696 DEFUN (elf_new_section_hook
, (abfd
, sec
),
700 struct bfd_elf_section_data
*sdata
;
702 sdata
= (struct bfd_elf_section_data
*) bfd_alloc (abfd
, sizeof (*sdata
));
703 sec
->used_by_bfd
= (PTR
) sdata
;
704 memset (sdata
, 0, sizeof (*sdata
));
708 /* Create a new bfd section from an ELF program header.
710 Since program segments have no names, we generate a synthetic name
711 of the form segment<NUM>, where NUM is generally the index in the
712 program header table. For segments that are split (see below) we
713 generate the names segment<NUM>a and segment<NUM>b.
715 Note that some program segments may have a file size that is different than
716 (less than) the memory size. All this means is that at execution the
717 system must allocate the amount of memory specified by the memory size,
718 but only initialize it with the first "file size" bytes read from the
719 file. This would occur for example, with program segments consisting
720 of combined data+bss.
722 To handle the above situation, this routine generates TWO bfd sections
723 for the single program segment. The first has the length specified by
724 the file size of the segment, and the second has the length specified
725 by the difference between the two sizes. In effect, the segment is split
726 into it's initialized and uninitialized parts.
731 DEFUN (bfd_section_from_phdr
, (abfd
, hdr
, index
),
733 Elf_Internal_Phdr
* hdr AND
741 split
= ((hdr
->p_memsz
> 0) &&
742 (hdr
->p_filesz
> 0) &&
743 (hdr
->p_memsz
> hdr
->p_filesz
));
744 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
745 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
746 strcpy (name
, namebuf
);
747 newsect
= bfd_make_section (abfd
, name
);
748 newsect
->vma
= hdr
->p_vaddr
;
749 newsect
->_raw_size
= hdr
->p_filesz
;
750 newsect
->filepos
= hdr
->p_offset
;
751 newsect
->flags
|= SEC_HAS_CONTENTS
;
752 if (hdr
->p_type
== PT_LOAD
)
754 newsect
->flags
|= SEC_ALLOC
;
755 newsect
->flags
|= SEC_LOAD
;
756 if (hdr
->p_flags
& PF_X
)
758 /* FIXME: all we known is that it has execute PERMISSION,
760 newsect
->flags
|= SEC_CODE
;
763 if (!(hdr
->p_flags
& PF_W
))
765 newsect
->flags
|= SEC_READONLY
;
770 sprintf (namebuf
, "segment%db", index
);
771 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
772 strcpy (name
, namebuf
);
773 newsect
= bfd_make_section (abfd
, name
);
774 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
775 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
776 if (hdr
->p_type
== PT_LOAD
)
778 newsect
->flags
|= SEC_ALLOC
;
779 if (hdr
->p_flags
& PF_X
)
780 newsect
->flags
|= SEC_CODE
;
782 if (!(hdr
->p_flags
& PF_W
))
783 newsect
->flags
|= SEC_READONLY
;
789 /* Begin processing a given object.
791 First we validate the file by reading in the ELF header and checking
794 static INLINE boolean
795 DEFUN (elf_file_p
, (x_ehdrp
), Elf_External_Ehdr
* x_ehdrp
)
797 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
798 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
799 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
800 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
803 /* Check to see if the file associated with ABFD matches the target vector
806 Note that we may be called several times with the same ABFD, but different
807 target vectors, most of which will not match. We have to avoid leaving
808 any side effects in ABFD, or any data it points to (like tdata), if the
809 file does not match the target vector.
811 FIXME: There is memory leak if we are called more than once with the same
812 ABFD, and that bfd already has tdata allocated, since we allocate more tdata
813 and the old tdata is orphaned. Since it's in the bfd obstack, there isn't
814 much we can do about this except possibly rewrite the code. There are
815 also other bfd_allocs that may be the source of memory leaks as well. */
818 DEFUN (elf_object_p
, (abfd
), bfd
* abfd
)
820 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
821 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
822 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
823 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
825 char *shstrtab
; /* Internal copy of section header stringtab */
826 struct elf_backend_data
*ebd
; /* Use to get ELF_ARCH stored in xvec */
827 struct elf_obj_tdata
*preserved_tdata
= elf_tdata (abfd
);
829 /* Read in the ELF header in external format. */
831 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
832 goto got_system_call_error
;
834 /* Now check to see if we have a valid ELF file, and one that BFD can
835 make use of. The magic number must match, the address size ('class')
836 and byte-swapping must match our XVEC entry, and it must have a
837 section header table (FIXME: See comments re sections at top of this
840 if ((elf_file_p (&x_ehdr
) == false) ||
841 (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
) ||
842 (x_ehdr
.e_ident
[EI_CLASS
] != ELFCLASS
))
843 goto got_wrong_format_error
;
845 /* Check that file's byte order matches xvec's */
846 switch (x_ehdr
.e_ident
[EI_DATA
])
848 case ELFDATA2MSB
: /* Big-endian */
849 if (!abfd
->xvec
->header_byteorder_big_p
)
850 goto got_wrong_format_error
;
852 case ELFDATA2LSB
: /* Little-endian */
853 if (abfd
->xvec
->header_byteorder_big_p
)
854 goto got_wrong_format_error
;
856 case ELFDATANONE
: /* No data encoding specified */
857 default: /* Unknown data encoding specified */
858 goto got_wrong_format_error
;
861 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
862 the tdata pointer in the bfd. FIXME: memory leak, see above. */
865 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
866 if (elf_tdata (abfd
) == NULL
)
867 goto got_no_memory_error
;
869 /* Now that we know the byte order, swap in the rest of the header */
870 i_ehdrp
= elf_elfheader (abfd
);
871 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
873 elf_debug_file (i_ehdrp
);
876 /* If there is no section header table, we're hosed. */
877 if (i_ehdrp
->e_shoff
== 0)
878 goto got_wrong_format_error
;
880 if (i_ehdrp
->e_type
== ET_EXEC
)
881 abfd
->flags
|= EXEC_P
;
882 else if (i_ehdrp
->e_type
== ET_DYN
)
883 abfd
->flags
|= DYNAMIC
;
885 /* Retrieve the architecture information from the xvec and verify
886 that it matches the machine info stored in the ELF header.
887 This allows us to resolve ambiguous formats that might not
888 otherwise be distinguishable. */
890 ebd
= get_elf_backend_data (abfd
);
892 /* Perhaps the elf architecture value should be another field in the
893 elf backend data? If you change this to work that way, make sure
894 that you still get bfd_arch_unknown for unknown architecture types,
895 and that it still gets accepted by the `generic' elf target. */
898 enum bfd_architecture arch
= bfd_arch_unknown
;
900 for (i
= 0; i
< bfd_elf_arch_map_size
; i
++)
902 if (bfd_elf_arch_map
[i
].elf_arch
== i_ehdrp
->e_machine
)
904 arch
= bfd_elf_arch_map
[i
].bfd_arch
;
908 /* start-sanitize-v9 */
909 if (i_ehdrp
->e_machine
== EM_SPARC64
)
910 arch
= bfd_arch_sparc
;
911 /* end-sanitize-v9 */
912 if (ebd
->arch
!= arch
)
913 goto got_wrong_format_error
;
914 bfd_default_set_arch_mach (abfd
, arch
, 0);
917 /* Allocate space for a copy of the section header table in
918 internal form, seek to the section header table in the file,
919 read it in, and convert it to internal form. As a simple sanity
920 check, verify that the what BFD thinks is the size of each section
921 header table entry actually matches the size recorded in the file. */
923 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
924 goto got_wrong_format_error
;
925 i_shdrp
= (Elf_Internal_Shdr
*)
926 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
);
927 elf_elfsections (abfd
) =
928 (Elf_Internal_Shdr
**) bfd_alloc (abfd
, sizeof (i_shdrp
) * i_ehdrp
->e_shnum
);
929 if (!i_shdrp
|| !elf_elfsections(abfd
))
930 goto got_no_memory_error
;
931 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) == -1)
932 goto got_system_call_error
;
933 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
935 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
) != sizeof (x_shdr
))
936 goto got_system_call_error
;
937 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
938 elf_elfsections(abfd
)[shindex
] = i_shdrp
+ shindex
;
940 if (i_ehdrp
->e_shstrndx
)
942 bfd_section_from_shdr (abfd
, i_ehdrp
->e_shstrndx
);
946 for (shindex
= i_ehdrp
->e_shnum
- 1; shindex
>= 0; shindex
--)
948 if (!strcmp (elf_string_from_elf_strtab (abfd
,
949 i_shdrp
[shindex
].sh_name
),
952 elf_tdata(abfd
)->strtab_hdr
= i_shdrp
[shindex
];
953 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->strtab_hdr
;
955 else if (!strcmp (elf_string_from_elf_strtab (abfd
,
956 i_shdrp
[shindex
].sh_name
),
959 elf_tdata(abfd
)->symtab_hdr
= i_shdrp
[shindex
];
960 elf_elfsections(abfd
)[shindex
] = &elf_tdata(abfd
)->symtab_hdr
;
961 elf_onesymtab (abfd
) = shindex
;
966 /* Read in the string table containing the names of the sections. We
967 will need the base pointer to this table later. */
968 /* We read this inline now, so that we don't have to go through
969 bfd_section_from_shdr with it (since this particular strtab is
970 used to find all of the ELF section names.) */
972 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
974 goto got_wrong_format_error
;
976 /* Once all of the section headers have been read and converted, we
977 can start processing them. Note that the first section header is
978 a dummy placeholder entry, so we ignore it.
980 We also watch for the symbol table section and remember the file
981 offset and section size for both the symbol table section and the
982 associated string table section. */
984 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
986 bfd_section_from_shdr (abfd
, shindex
);
989 /* Remember the entry point specified in the ELF file header. */
991 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
995 /* If we are going to use goto's to avoid duplicating error setting
996 and return(NULL) code, then this at least makes it more maintainable. */
998 got_system_call_error
:
999 bfd_error
= system_call_error
;
1001 got_wrong_format_error
:
1002 bfd_error
= wrong_format
;
1004 got_no_memory_error
:
1005 bfd_error
= no_memory
;
1008 elf_tdata (abfd
) = preserved_tdata
;
1013 /* ELF .o/exec file writing */
1015 /* Takes a bfd and a symbol, returns a pointer to the elf specific area
1016 of the symbol if there is one. */
1017 static INLINE elf_symbol_type
*
1018 DEFUN (elf_symbol_from
, (ignore_abfd
, symbol
),
1019 bfd
* ignore_abfd AND
1022 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1025 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1028 return (elf_symbol_type
*) symbol
;
1031 /* Create ELF output from BFD sections.
1033 Essentially, just create the section header and forget about the program
1037 DEFUN (elf_make_sections
, (abfd
, asect
, obj
),
1039 asection
* asect AND
1042 /* most of what is in bfd_shdr_from_section goes in here... */
1043 /* and all of these sections generate at *least* one ELF section. */
1044 Elf_Internal_Shdr
*this_hdr
;
1045 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1047 this_hdr
->sh_addr
= asect
->vma
;
1048 this_hdr
->sh_size
= asect
->_raw_size
;
1049 /* contents already set by elf_set_section_contents */
1051 if (asect
->flags
& SEC_RELOC
)
1053 /* emit a reloc section, and thus strtab and symtab... */
1054 Elf_Internal_Shdr
*rela_hdr
;
1055 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1057 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1059 /* orelocation has the data, reloc_count has the count... */
1062 rela_hdr
->sh_type
= SHT_RELA
;
1063 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1066 /* REL relocations */
1068 rela_hdr
->sh_type
= SHT_REL
;
1069 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1071 rela_hdr
->sh_flags
= 0;
1072 rela_hdr
->sh_addr
= 0;
1073 rela_hdr
->sh_offset
= 0;
1074 rela_hdr
->sh_addralign
= 0;
1077 if (asect
->flags
& SEC_ALLOC
)
1079 this_hdr
->sh_flags
|= SHF_ALLOC
;
1080 if (asect
->flags
& SEC_LOAD
)
1082 /* @@ Do something with sh_type? */
1087 /* If this section is not part of the program image during
1088 execution, leave the address fields at 0. */
1089 this_hdr
->sh_addr
= 0;
1092 if (!(asect
->flags
& SEC_READONLY
))
1093 this_hdr
->sh_flags
|= SHF_WRITE
;
1095 if (asect
->flags
& SEC_CODE
)
1096 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1100 write_relocs (abfd
, sec
, xxx
)
1105 Elf_Internal_Shdr
*rela_hdr
;
1106 Elf_External_Rela
*outbound_relocas
;
1107 Elf_External_Rel
*outbound_relocs
;
1109 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1110 asymbol
*last_sym
= 0;
1113 if ((sec
->flags
& SEC_RELOC
) == 0)
1115 /* Flags are sometimes inconsistent. */
1116 if (sec
->reloc_count
== 0)
1119 rela_hdr
= &elf_section_data (sec
)->rel_hdr
;
1121 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* sec
->reloc_count
;
1122 rela_hdr
->contents
= (void *) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1124 /* orelocation has the data, reloc_count has the count... */
1127 outbound_relocas
= (Elf_External_Rela
*) rela_hdr
->contents
;
1129 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1131 Elf_Internal_Rela dst_rela
;
1132 Elf_External_Rela
*src_rela
;
1137 ptr
= sec
->orelocation
[idx
];
1138 src_rela
= outbound_relocas
+ idx
;
1139 if (!(abfd
->flags
& EXEC_P
))
1140 dst_rela
.r_offset
= ptr
->address
- sec
->vma
;
1142 dst_rela
.r_offset
= ptr
->address
;
1144 sym
= *ptr
->sym_ptr_ptr
;
1145 if (sym
== last_sym
)
1150 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1152 dst_rela
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1154 dst_rela
.r_addend
= ptr
->addend
;
1155 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1159 /* REL relocations */
1161 outbound_relocs
= (Elf_External_Rel
*) rela_hdr
->contents
;
1163 for (idx
= 0; idx
< sec
->reloc_count
; idx
++)
1165 Elf_Internal_Rel dst_rel
;
1166 Elf_External_Rel
*src_rel
;
1171 ptr
= sec
->orelocation
[idx
];
1172 sym
= *ptr
->sym_ptr_ptr
;
1173 src_rel
= outbound_relocs
+ idx
;
1174 if (!(abfd
->flags
& EXEC_P
))
1175 dst_rel
.r_offset
= ptr
->address
- sec
->vma
;
1177 dst_rel
.r_offset
= ptr
->address
;
1179 if (sym
== last_sym
)
1184 last_sym_idx
= n
= elf_symbol_from_bfd_symbol (abfd
, &sym
);
1186 dst_rel
.r_info
= ELF_R_INFO (n
, ptr
->howto
->type
);
1188 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1194 fix_up_strtabs (abfd
, asect
, obj
)
1199 Elf_Internal_Shdr
*this_hdr
= &elf_section_data (asect
)->this_hdr
;
1200 int this_idx
= elf_section_data(asect
)->this_idx
;
1202 /* @@ Check flags! */
1203 if (!strncmp (asect
->name
, ".stab", 5)
1204 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
1206 size_t len
= strlen (asect
->name
) + 1;
1207 char *s
= (char *) alloca (len
);
1208 strcpy (s
, asect
->name
);
1210 asect
= bfd_get_section_by_name (abfd
, s
);
1213 elf_section_data(asect
)->this_hdr
.sh_link
= this_idx
;
1214 /* @@ Assuming 32 bits! */
1215 elf_section_data(asect
)->this_hdr
.sh_entsize
= 0xc;
1217 this_hdr
->sh_type
= SHT_STRTAB
;
1222 DEFUN (elf_fake_sections
, (abfd
, asect
, obj
),
1224 asection
* asect AND
1227 /* most of what is in bfd_shdr_from_section goes in here... */
1228 /* and all of these sections generate at *least* one ELF section. */
1230 Elf_Internal_Shdr
*this_hdr
;
1231 this_hdr
= &elf_section_data (asect
)->this_hdr
;
1233 bfd_add_to_strtab (abfd
, elf_shstrtab (abfd
), asect
->name
);
1234 /* We need to log the type *now* so that elf_section_from_bfd_section
1235 can find us... have to set rawdata too. */
1236 this_hdr
->rawdata
= (void *) asect
;
1237 this_hdr
->sh_addralign
= 1 << asect
->alignment_power
;
1238 if ((asect
->flags
& SEC_ALLOC
) && (asect
->flags
& SEC_LOAD
))
1239 this_hdr
->sh_type
= SHT_PROGBITS
;
1240 else if ((asect
->flags
& SEC_ALLOC
) && ((asect
->flags
& SEC_LOAD
) == 0))
1242 BFD_ASSERT (!strcmp (asect
->name
, ".bss"));
1243 this_hdr
->sh_type
= SHT_NOBITS
;
1245 /* FIXME I am not sure how to detect a .note section from the flags
1246 word of an `asection'. */
1247 else if (!strcmp (asect
->name
, ".note"))
1248 this_hdr
->sh_type
= SHT_NOTE
;
1250 this_hdr
->sh_type
= SHT_PROGBITS
;
1252 this_hdr
->sh_flags
= 0;
1253 this_hdr
->sh_addr
= 0;
1254 this_hdr
->sh_size
= 0;
1255 this_hdr
->sh_entsize
= 0;
1256 this_hdr
->sh_info
= 0;
1257 this_hdr
->sh_link
= 0;
1258 this_hdr
->sh_offset
= 0;
1261 /* Now, check for processor-specific section types. */
1263 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
1265 if (bed
->elf_backend_fake_sections
)
1266 (*bed
->elf_backend_fake_sections
) (abfd
, this_hdr
, asect
);
1270 /* Emit a strtab and symtab, and possibly a reloc section. */
1271 Elf_Internal_Shdr
*rela_hdr
;
1273 /* Note that only one symtab is used, so just remember it
1276 if (asect
->flags
& SEC_RELOC
)
1278 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1280 rela_hdr
= &elf_section_data (asect
)->rel_hdr
;
1282 bfd_add_2_to_strtab (abfd
, elf_shstrtab (abfd
),
1283 use_rela_p
? ".rela" : ".rel",
1285 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1286 rela_hdr
->sh_entsize
= (use_rela_p
1287 ? sizeof (Elf_External_Rela
)
1288 : sizeof (Elf_External_Rel
));
1290 rela_hdr
->sh_flags
= 0;
1291 rela_hdr
->sh_addr
= 0;
1292 rela_hdr
->sh_size
= 0;
1293 rela_hdr
->sh_offset
= 0;
1294 rela_hdr
->sh_addralign
= 0;
1298 if (asect
->flags
& SEC_ALLOC
)
1300 this_hdr
->sh_flags
|= SHF_ALLOC
;
1301 if (asect
->flags
& SEC_LOAD
)
1303 /* @@ Do something with sh_type? */
1306 if (!(asect
->flags
& SEC_READONLY
))
1307 this_hdr
->sh_flags
|= SHF_WRITE
;
1308 if (asect
->flags
& SEC_CODE
)
1309 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1312 /* Map symbol from it's internal number to the external number, moving
1313 all local symbols to be at the head of the list. */
1319 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
1321 if (sym
->flags
& BSF_LOCAL
)
1325 if (sym
->section
== 0)
1327 /* Is this valid? */
1332 if (sym
->section
== &bfd_und_section
)
1334 if (bfd_is_com_section (sym
->section
))
1336 if (sym
->flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1342 DEFUN (elf_map_symbols
, (abfd
), bfd
* abfd
)
1344 int symcount
= bfd_get_symcount (abfd
);
1345 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1346 asymbol
**sect_syms
;
1348 int num_globals
= 0;
1349 int num_locals2
= 0;
1350 int num_globals2
= 0;
1352 int num_sections
= 0;
1353 Elf_Sym_Extra
*sym_extra
;
1358 fprintf (stderr
, "elf_map_symbols\n");
1362 /* Add local symbols for each section for which there are relocs.
1363 FIXME: How can we tell which sections have relocs at this point?
1364 Will reloc_count always be accurate? Actually, I think most ELF
1365 targets create section symbols for all sections anyhow. */
1366 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1368 if (max_index
< asect
->index
)
1369 max_index
= asect
->index
;
1373 elf_num_section_syms (abfd
) = max_index
;
1374 sect_syms
= (asymbol
**) bfd_zalloc (abfd
, max_index
* sizeof (asymbol
*));
1375 elf_section_syms (abfd
) = sect_syms
;
1377 BFD_ASSERT (sect_syms
!= 0);
1379 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1381 asymbol
*sym
= bfd_make_empty_symbol (abfd
);
1382 sym
->the_bfd
= abfd
;
1383 sym
->name
= asect
->name
;
1384 sym
->value
= asect
->vma
;
1385 sym
->flags
= BSF_SECTION_SYM
;
1386 sym
->section
= asect
;
1387 sect_syms
[asect
->index
] = sym
;
1391 "creating section symbol, name = %s, value = 0x%.8lx, index = %d, section = 0x%.8lx\n",
1392 asect
->name
, (long) asect
->vma
, asect
->index
, (long) asect
);
1399 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1400 ((symcount
+ num_sections
+ 1)
1401 * sizeof (asymbol
*)));
1403 syms
= (asymbol
**) bfd_alloc (abfd
,
1404 (num_sections
+ 1) * sizeof (asymbol
*));
1406 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1408 if (sect_syms
[asect
->index
])
1409 syms
[symcount
++] = sect_syms
[asect
->index
];
1412 syms
[symcount
] = (asymbol
*) 0;
1413 bfd_set_symtab (abfd
, syms
, symcount
);
1416 elf_sym_extra (abfd
) = sym_extra
1417 = (Elf_Sym_Extra
*) bfd_alloc (abfd
, symcount
* sizeof (Elf_Sym_Extra
));
1419 /* Identify and classify all of the symbols. */
1420 for (idx
= 0; idx
< symcount
; idx
++)
1422 if (!sym_is_global (syms
[idx
]))
1428 /* Now provide mapping information. Add +1 for skipping over the
1430 for (idx
= 0; idx
< symcount
; idx
++)
1432 syms
[idx
]->udata
= (PTR
) &sym_extra
[idx
];
1433 if (!sym_is_global (syms
[idx
]))
1434 sym_extra
[idx
].elf_sym_num
= 1 + num_locals2
++;
1436 sym_extra
[idx
].elf_sym_num
= 1 + num_locals
+ num_globals2
++;
1439 elf_num_locals (abfd
) = num_locals
;
1440 elf_num_globals (abfd
) = num_globals
;
1443 static void assign_section_numbers ();
1444 static void assign_file_positions_except_relocs ();
1447 DEFUN (elf_compute_section_file_positions
, (abfd
), bfd
* abfd
)
1449 bfd_map_over_sections (abfd
, elf_fake_sections
, 0);
1451 assign_section_numbers (abfd
);
1453 bfd_map_over_sections (abfd
, elf_make_sections
, 0);
1455 bfd_map_over_sections (abfd
, fix_up_strtabs
, 0); /* .stab/.stabstr &c */
1457 swap_out_syms (abfd
);
1459 assign_file_positions_except_relocs (abfd
);
1465 DEFUN (elf_write_phdrs
, (abfd
, i_ehdrp
, i_phdrp
, phdr_cnt
),
1467 Elf_Internal_Ehdr
* i_ehdrp AND
1468 Elf_Internal_Phdr
* i_phdrp AND
1469 Elf32_Half phdr_cnt
)
1471 /* first program header entry goes after the file header */
1472 int outbase
= i_ehdrp
->e_phoff
;
1474 Elf_External_Phdr x_phdr
;
1476 for (i
= 0; i
< phdr_cnt
; i
++)
1478 elf_swap_phdr_out (abfd
, i_phdrp
+ i
, &x_phdr
);
1479 bfd_seek (abfd
, outbase
, SEEK_SET
);
1480 bfd_write ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
);
1481 outbase
+= sizeof (x_phdr
);
1487 static const Elf_Internal_Shdr null_shdr
;
1489 /* Assign all ELF section numbers. The dummy first section is handled here
1490 too. The link/info pointers for the standard section types are filled
1491 in here too, while we're at it. (Link pointers for .stab sections are
1492 not filled in here.) */
1494 assign_section_numbers (abfd
)
1497 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1499 int section_number
= 1;
1501 Elf_Internal_Shdr
**i_shdrp
;
1503 t
->shstrtab_hdr
.sh_size
= elf_shstrtab(abfd
)->length
;
1504 t
->shstrtab_hdr
.contents
= (void *) elf_shstrtab(abfd
)->tab
;
1505 shstrtab_length_fixed
= 1;
1507 t
->shstrtab_section
= section_number
++;
1508 elf_elfheader(abfd
)->e_shstrndx
= t
->shstrtab_section
;
1511 t
->symtab_section
= section_number
++;
1512 t
->strtab_section
= section_number
++;
1513 t
->symtab_hdr
.sh_link
= t
->strtab_section
;
1515 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1517 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1518 d
->this_idx
= section_number
++;
1519 if (sec
->flags
& SEC_RELOC
)
1521 d
->rel_idx
= section_number
++;
1522 d
->rel_hdr
.sh_link
= t
->symtab_section
;
1523 d
->rel_hdr
.sh_info
= d
->this_idx
;
1527 /* No handling for per-section string tables currently. */
1529 elf_elfheader(abfd
)->e_shnum
= section_number
;
1531 /* Set up the list of section header pointers, in agreement with the
1533 i_shdrp
= (Elf_Internal_Shdr
**)
1534 bfd_alloc (abfd
, section_number
* sizeof (Elf_Internal_Shdr
*));
1535 elf_elfsections(abfd
) = i_shdrp
;
1536 for (i
= 0; i
< section_number
; i
++)
1539 i_shdrp
[0] = (Elf_Internal_Shdr
*) &null_shdr
;
1540 i_shdrp
[t
->shstrtab_section
] = &t
->shstrtab_hdr
;
1543 i_shdrp
[t
->symtab_section
] = &t
->symtab_hdr
;
1544 i_shdrp
[t
->strtab_section
] = &t
->strtab_hdr
;
1546 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
1548 struct bfd_elf_section_data
*d
= elf_section_data (sec
);
1549 i_shdrp
[d
->this_idx
] = &d
->this_hdr
;
1551 i_shdrp
[d
->rel_idx
] = &d
->rel_hdr
;
1553 /* Make sure we got everything.... */
1554 for (i
= 0; i
< section_number
; i
++)
1555 if (i_shdrp
[i
] == 0)
1559 static INLINE file_ptr
1560 assign_file_position_for_section (i_shdrp
, offset
)
1561 Elf_Internal_Shdr
*i_shdrp
;
1566 if (i_shdrp
->sh_addralign
!= 0)
1567 align
= i_shdrp
->sh_addralign
;
1570 i_shdrp
->sh_offset
= offset
= BFD_ALIGN (offset
, align
);
1571 if (i_shdrp
->rawdata
!= NULL
)
1572 ((asection
*) i_shdrp
->rawdata
)->filepos
= offset
;
1573 if (i_shdrp
->sh_type
!= SHT_NOBITS
)
1574 offset
+= i_shdrp
->sh_size
;
1578 static INLINE file_ptr
1579 align_file_position (off
)
1582 return (off
+ FILE_ALIGN
- 1) & ~(FILE_ALIGN
- 1);
1585 static INLINE file_ptr
1586 assign_file_positions_for_symtab_and_strtabs (abfd
, off
)
1590 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
1592 off
= align_file_position (off
);
1593 off
= assign_file_position_for_section (&t
->symtab_hdr
, off
);
1594 off
= assign_file_position_for_section (&t
->shstrtab_hdr
, off
);
1595 off
= assign_file_position_for_section (&t
->strtab_hdr
, off
);
1600 bfd_vma low
, mem_size
;
1604 struct seg_info
*next
;
1608 map_program_segments (abfd
)
1611 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1612 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1613 Elf_Internal_Shdr
*i_shdrp
;
1614 Elf_Internal_Phdr
*phdr
;
1617 file_ptr lowest_offset
= 0;
1618 struct seg_info
*seg
= 0;
1620 done
= (char *) alloca (i_ehdrp
->e_shnum
);
1621 memset (done
, 0, i_ehdrp
->e_shnum
);
1622 for (i
= 0; i
< i_ehdrp
->e_shnum
; i
++)
1624 i_shdrp
= i_shdrpp
[i
];
1625 /* If it's going to be mapped in, it's been assigned a position. */
1626 if (i_shdrp
->sh_offset
+ 1 == 0)
1628 /* Well, not really, but we won't process it here. */
1632 if (i_shdrp
->sh_offset
< lowest_offset
1633 || lowest_offset
== 0)
1634 lowest_offset
= i_shdrp
->sh_offset
;
1635 /* Only interested in PROGBITS or NOBITS for generating segments. */
1636 switch (i_shdrp
->sh_type
)
1649 bfd_vma lowest_vma
= -1, high
;
1654 for (i
= 1; i
< i_ehdrp
->e_shnum
; i
++)
1656 i_shdrp
= i_shdrpp
[i
];
1657 if (!done
[i
] && i_shdrp
->sh_addr
< lowest_vma
)
1659 lowest_vma
= i_shdrp
->sh_addr
;
1665 /* So now we know the lowest vma of any unassigned sections; start
1669 s
= (struct seg_info
*) bfd_alloc (abfd
, sizeof (struct seg_info
));
1673 seg
->low
= lowest_vma
;
1674 i_shdrp
= i_shdrpp
[low_sec
];
1675 seg
->start_pos
= i_shdrp
->sh_offset
;
1676 seg
->sh_flags
= i_shdrp
->sh_flags
;
1677 done
[low_sec
] = 1, n_left
--;
1678 mem_size
= i_shdrp
->sh_size
;
1679 high
= lowest_vma
+ i_shdrp
->sh_size
;
1681 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1682 file_size
= i_shdrp
->sh_size
;
1684 for (i
= 0; i
< i_ehdrp
->e_shnum
; i
++)
1688 if (file_size
!= mem_size
)
1692 i_shdrp
= i_shdrpp
[i
];
1693 /* position of next byte on disk */
1694 f1
= seg
->start_pos
+ file_size
;
1695 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1697 if (i_shdrp
->sh_offset
- f1
!= i_shdrp
->sh_addr
- high
)
1700 else /* sh_type == NOBITS */
1702 /* If the section in question has no contents in the disk
1703 file, we really don't care where it supposedly starts.
1704 But we don't want to bother merging it into this segment
1705 if it doesn't start on this memory page. */
1706 bfd_vma page1
, page2
;
1707 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1709 /* page number in address space of current end of seg */
1710 page1
= (high
- 1 + maxpagesize
- 1) / maxpagesize
;
1711 /* page number in address space of start of this section */
1712 page2
= (i_shdrp
->sh_addr
+ maxpagesize
- 1) / maxpagesize
;
1717 done
[i
] = 1, n_left
--;
1718 if (i_shdrp
->sh_type
== SHT_PROGBITS
)
1719 file_size
= i_shdrp
->sh_offset
+ i_shdrp
->sh_size
- seg
->start_pos
;
1720 mem_size
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
- seg
->low
;
1721 high
= i_shdrp
->sh_addr
+ i_shdrp
->sh_size
;
1724 seg
->file_size
= file_size
;
1725 seg
->mem_size
= mem_size
;
1727 /* Now do something with the list of segments we've built up. */
1729 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1734 for (s
= seg
; s
; s
= s
->next
)
1738 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1739 sz
= sizeof (Elf_External_Phdr
) * n_segs
;
1740 if (align_file_position (i_ehdrp
->e_ehsize
) + sz
<= lowest_offset
)
1741 i_ehdrp
->e_phoff
= align_file_position (i_ehdrp
->e_ehsize
);
1744 i_ehdrp
->e_phoff
= align_file_position (elf_tdata (abfd
)->next_file_pos
);
1745 elf_tdata (abfd
)->next_file_pos
= i_ehdrp
->e_phoff
+ sz
;
1747 phdr
= (Elf_Internal_Phdr
*) bfd_alloc (abfd
,
1748 n_segs
* sizeof (Elf_Internal_Phdr
));
1749 elf_tdata (abfd
)->phdr
= phdr
;
1752 phdr
->p_type
= PT_LOAD
; /* only type we really support so far */
1753 phdr
->p_offset
= seg
->start_pos
;
1754 phdr
->p_vaddr
= seg
->low
;
1756 phdr
->p_filesz
= seg
->file_size
;
1757 phdr
->p_memsz
= seg
->mem_size
;
1758 phdr
->p_flags
= PF_R
;
1759 phdr
->p_align
= maxpagesize
; /* ? */
1760 if (seg
->sh_flags
& SHF_WRITE
)
1761 /* SysVr4 ELF docs say "data segments normally have read, write,
1762 and execute permissions." */
1763 phdr
->p_flags
|= (PF_W
| PF_X
);
1764 if (seg
->sh_flags
& SHF_EXECINSTR
)
1765 phdr
->p_flags
|= PF_X
;
1769 i_ehdrp
->e_phnum
= n_segs
;
1771 elf_write_phdrs (abfd
, i_ehdrp
, elf_tdata (abfd
)->phdr
, i_ehdrp
->e_phnum
);
1775 assign_file_positions_except_relocs (abfd
)
1778 /* For now, we ignore the possibility of having program segments, which
1779 may require some alignment in the file. That'll require padding, and
1780 some interesting calculations to optimize file space usage.
1782 Also, since the application may change the list of relocations for
1783 a given section, we don't figure them in here. We'll put them at the
1784 end of the file, at positions computed during bfd_close.
1786 The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
1787 or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
1791 Elf_Internal_Shdr
**i_shdrpp
= elf_elfsections (abfd
);
1792 Elf_Internal_Shdr
*i_shdrp
;
1793 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
1794 int exec_p
= (abfd
->flags
& EXEC_P
) != 0;
1796 /* Everything starts after the ELF file header. */
1797 off
= i_ehdrp
->e_ehsize
;
1801 /* Section headers. */
1802 off
= align_file_position (off
);
1803 i_ehdrp
->e_shoff
= off
;
1804 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1806 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1808 for (i
= 0; i
< i_ehdrp
->e_shnum
; i
++)
1810 i_shdrp
= i_shdrpp
[i
];
1811 if (i_shdrp
->sh_type
== SHT_REL
|| i_shdrp
->sh_type
== SHT_RELA
)
1813 i_shdrp
->sh_offset
= -1;
1818 bfd_vma maxpagesize
= get_elf_backend_data (abfd
)->maxpagesize
;
1819 if (maxpagesize
== 0)
1820 maxpagesize
= 1; /* make the arithmetic work */
1821 /* This isn't necessarily going to give the best packing, if the
1822 segments require padding between them, but since that isn't
1823 usually the case, this'll do. */
1824 if ((i_shdrp
->sh_flags
& SHF_ALLOC
) == 0)
1826 i_shdrp
->sh_offset
= -1;
1829 /* Blindly assume that the segments are ordered optimally. With
1830 the default LD script, they will be. */
1832 /* need big unsigned type */
1834 addtl_off
= i_shdrp
->sh_addr
- off
;
1835 addtl_off
= addtl_off
% maxpagesize
;
1841 if (i_shdrp
->sh_type
== SHT_NOBITS
)
1844 i_shdrp
->sh_offset
= off
;
1845 if (off
% maxpagesize
!= 0)
1846 off2
= maxpagesize
- (off
% maxpagesize
);
1847 if (off2
> i_shdrp
->sh_size
)
1848 off2
= i_shdrp
->sh_size
;
1852 off
= assign_file_position_for_section (i_shdrp
, off
);
1855 && get_elf_backend_data(abfd
)->maxpagesize
> 1
1856 && i_shdrp
->sh_type
== SHT_PROGBITS
1857 && (i_shdrp
->sh_flags
& SHF_ALLOC
)
1858 && (i_shdrp
->sh_offset
- i_shdrp
->sh_addr
) % get_elf_backend_data (abfd
)->maxpagesize
!= 0)
1863 elf_tdata (abfd
)->next_file_pos
= off
;
1864 map_program_segments (abfd
);
1865 off
= elf_tdata (abfd
)->next_file_pos
;
1867 /* Section headers. */
1868 off
= align_file_position (off
);
1869 i_ehdrp
->e_shoff
= off
;
1870 off
+= i_ehdrp
->e_shnum
* i_ehdrp
->e_shentsize
;
1872 off
= assign_file_positions_for_symtab_and_strtabs (abfd
, off
);
1874 for (i
= 0; i
< i_ehdrp
->e_shnum
; i
++)
1876 i_shdrp
= i_shdrpp
[i
];
1877 if (i_shdrp
->sh_offset
+ 1 == 0
1878 && i_shdrp
->sh_type
!= SHT_REL
1879 && i_shdrp
->sh_type
!= SHT_RELA
)
1880 off
= assign_file_position_for_section (i_shdrp
, off
);
1883 elf_tdata (abfd
)->next_file_pos
= off
;
1890 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1891 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
1892 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
1894 struct strtab
*shstrtab
;
1896 i_ehdrp
= elf_elfheader (abfd
);
1897 i_shdrp
= elf_elfsections (abfd
);
1899 shstrtab
= bfd_new_strtab (abfd
);
1900 elf_shstrtab (abfd
) = shstrtab
;
1902 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
1903 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
1904 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
1905 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
1907 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS
;
1908 i_ehdrp
->e_ident
[EI_DATA
] =
1909 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
1910 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1912 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
1913 i_ehdrp
->e_ident
[count
] = 0;
1915 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
1916 switch (bfd_get_arch (abfd
))
1918 case bfd_arch_unknown
:
1919 i_ehdrp
->e_machine
= EM_NONE
;
1921 case bfd_arch_sparc
:
1922 i_ehdrp
->e_machine
= EM_SPARC
;
1923 /* start-sanitize-v9 */
1925 i_ehdrp
->e_machine
= EM_SPARC64
;
1927 /* end-sanitize-v9 */
1930 i_ehdrp
->e_machine
= EM_386
;
1933 i_ehdrp
->e_machine
= EM_68K
;
1936 i_ehdrp
->e_machine
= EM_88K
;
1939 i_ehdrp
->e_machine
= EM_860
;
1941 case bfd_arch_mips
: /* MIPS Rxxxx */
1942 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
1945 i_ehdrp
->e_machine
= EM_HPPA
;
1947 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
1949 i_ehdrp
->e_machine
= EM_NONE
;
1951 i_ehdrp
->e_version
= EV_CURRENT
;
1952 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
1954 /* no program header, for now. */
1955 i_ehdrp
->e_phoff
= 0;
1956 i_ehdrp
->e_phentsize
= 0;
1957 i_ehdrp
->e_phnum
= 0;
1959 /* each bfd section is section header entry */
1960 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
1961 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
1963 /* if we're building an executable, we'll need a program header table */
1964 if (abfd
->flags
& EXEC_P
)
1966 /* it all happens later */
1968 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
1970 /* elf_build_phdrs() returns a (NULL-terminated) array of
1971 Elf_Internal_Phdrs */
1972 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
1973 i_ehdrp
->e_phoff
= outbase
;
1974 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
1979 i_ehdrp
->e_phentsize
= 0;
1981 i_ehdrp
->e_phoff
= 0;
1984 elf_tdata (abfd
)->symtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
1986 elf_tdata (abfd
)->strtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
1988 elf_tdata (abfd
)->shstrtab_hdr
.sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
1994 swap_out_syms (abfd
)
1997 elf_map_symbols (abfd
);
1999 /* Dump out the symtabs. */
2001 int symcount
= bfd_get_symcount (abfd
);
2002 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2003 struct strtab
*stt
= bfd_new_strtab (abfd
);
2004 Elf_Internal_Shdr
*symtab_hdr
;
2005 Elf_Internal_Shdr
*symstrtab_hdr
;
2006 Elf_External_Sym
*outbound_syms
;
2009 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2010 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2011 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2012 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2013 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2015 /* see assert in elf_fake_sections that supports this: */
2016 symstrtab_hdr
= &elf_tdata (abfd
)->strtab_hdr
;
2017 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2019 outbound_syms
= (Elf_External_Sym
*)
2020 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2021 /* now generate the data (for "contents") */
2023 /* Fill in zeroth symbol and swap it out. */
2024 Elf_Internal_Sym sym
;
2030 sym
.st_shndx
= SHN_UNDEF
;
2031 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2033 for (idx
= 0; idx
< symcount
; idx
++)
2035 Elf_Internal_Sym sym
;
2036 bfd_vma value
= syms
[idx
]->value
;
2038 if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2039 /* Section symbols have no names. */
2042 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2044 if (bfd_is_com_section (syms
[idx
]->section
))
2046 /* ELF common symbols put the alignment into the `value' field,
2047 and the size into the `size' field. This is backwards from
2048 how BFD handles it, so reverse it here. */
2049 sym
.st_size
= value
;
2050 /* Should retrieve this from somewhere... */
2052 sym
.st_shndx
= SHN_COMMON
;
2056 asection
*sec
= syms
[idx
]->section
;
2057 elf_symbol_type
*type_ptr
;
2060 if (sec
->output_section
)
2062 value
+= sec
->output_offset
;
2063 sec
= sec
->output_section
;
2066 sym
.st_value
= value
;
2067 type_ptr
= elf_symbol_from (abfd
, syms
[idx
]);
2068 sym
.st_size
= type_ptr
? type_ptr
->internal_elf_sym
.st_size
: 0;
2069 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec
);
2073 /* Writing this would be a hell of a lot easier if we had
2074 some decent documentation on bfd, and knew what to expect
2075 of the library, and what to demand of applications. For
2076 example, it appears that `objcopy' might not set the
2077 section of a symbol to be a section that is actually in
2079 sec2
= bfd_get_section_by_name (abfd
, sec
->name
);
2081 sym
.st_shndx
= shndx
= elf_section_from_bfd_section (abfd
, sec2
);
2082 assert (shndx
!= -1);
2086 if (bfd_is_com_section (syms
[idx
]->section
))
2087 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2088 else if (syms
[idx
]->section
== &bfd_und_section
)
2089 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_NOTYPE
);
2090 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2091 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2092 else if (syms
[idx
]->flags
& BSF_FILE
)
2093 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2096 int bind
= STB_LOCAL
;
2097 int type
= STT_OBJECT
;
2098 unsigned int flags
= syms
[idx
]->flags
;
2100 if (flags
& BSF_LOCAL
)
2102 else if (flags
& BSF_WEAK
)
2104 else if (flags
& BSF_GLOBAL
)
2107 if (flags
& BSF_FUNCTION
)
2110 sym
.st_info
= ELF_ST_INFO (bind
, type
);
2114 elf_swap_symbol_out (abfd
, &sym
,
2116 + elf_sym_extra (abfd
)[idx
].elf_sym_num
));
2119 symtab_hdr
->contents
= (PTR
) outbound_syms
;
2120 symstrtab_hdr
->contents
= (PTR
) stt
->tab
;
2121 symstrtab_hdr
->sh_size
= stt
->length
;
2122 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2124 symstrtab_hdr
->sh_flags
= 0;
2125 symstrtab_hdr
->sh_addr
= 0;
2126 symstrtab_hdr
->sh_entsize
= 0;
2127 symstrtab_hdr
->sh_link
= 0;
2128 symstrtab_hdr
->sh_info
= 0;
2129 symstrtab_hdr
->sh_addralign
= 0;
2130 symstrtab_hdr
->size
= 0;
2133 /* put the strtab out too... */
2135 Elf_Internal_Shdr
*this_hdr
;
2137 this_hdr
= &elf_tdata(abfd
)->shstrtab_hdr
;
2138 this_hdr
->contents
= (PTR
) elf_shstrtab (abfd
)->tab
;
2139 this_hdr
->sh_size
= elf_shstrtab (abfd
)->length
;
2140 this_hdr
->sh_type
= SHT_STRTAB
;
2141 this_hdr
->sh_flags
= 0;
2142 this_hdr
->sh_addr
= 0;
2143 this_hdr
->sh_entsize
= 0;
2144 this_hdr
->sh_addralign
= 0;
2150 write_shdrs_and_ehdr (abfd
)
2153 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2154 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2155 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2156 Elf_Internal_Shdr
**i_shdrp
; /* Section header table, internal form */
2158 struct strtab
*shstrtab
;
2160 i_ehdrp
= elf_elfheader (abfd
);
2161 i_shdrp
= elf_elfsections (abfd
);
2162 shstrtab
= elf_shstrtab (abfd
);
2164 /* swap the header before spitting it out... */
2167 elf_debug_file (i_ehdrp
);
2169 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2170 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
2171 bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
);
2173 /* at this point we've concocted all the ELF sections... */
2174 x_shdrp
= (Elf_External_Shdr
*)
2175 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2178 bfd_error
= no_memory
;
2182 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2185 elf_debug_section (shstrtab
->tab
+ i_shdrp
[count
]->sh_name
, count
,
2188 elf_swap_shdr_out (abfd
, i_shdrp
[count
], x_shdrp
+ count
);
2190 bfd_seek (abfd
, (file_ptr
) i_ehdrp
->e_shoff
, SEEK_SET
);
2191 bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
);
2192 /* need to dump the string table too... */
2198 assign_file_positions_for_relocs (abfd
)
2201 file_ptr off
= elf_tdata(abfd
)->next_file_pos
;
2203 Elf_Internal_Shdr
**shdrpp
= elf_elfsections (abfd
);
2204 Elf_Internal_Shdr
*shdrp
;
2205 for (i
= 0; i
< elf_elfheader(abfd
)->e_shnum
; i
++)
2208 if (shdrp
->sh_type
!= SHT_REL
&& shdrp
->sh_type
!= SHT_RELA
)
2210 off
= align_file_position (off
);
2211 off
= assign_file_position_for_section (shdrp
, off
);
2213 elf_tdata(abfd
)->next_file_pos
= off
;
2217 DEFUN (NAME(bfd_elf
,write_object_contents
), (abfd
), bfd
* abfd
)
2219 Elf_Internal_Ehdr
*i_ehdrp
;
2220 Elf_Internal_Shdr
**i_shdrp
;
2223 if (abfd
->output_has_begun
== false)
2225 prep_headers (abfd
);
2226 elf_compute_section_file_positions (abfd
);
2227 abfd
->output_has_begun
= true;
2230 i_shdrp
= elf_elfsections (abfd
);
2231 i_ehdrp
= elf_elfheader (abfd
);
2233 bfd_map_over_sections (abfd
, write_relocs
, (PTR
) 0);
2234 assign_file_positions_for_relocs (abfd
);
2236 /* After writing the headers, we need to write the sections too... */
2237 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2239 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2241 if (bed
->elf_backend_section_processing
)
2242 (*bed
->elf_backend_section_processing
) (abfd
, i_shdrp
[count
]);
2243 if (i_shdrp
[count
]->contents
)
2245 bfd_seek (abfd
, i_shdrp
[count
]->sh_offset
, SEEK_SET
);
2246 bfd_write (i_shdrp
[count
]->contents
, i_shdrp
[count
]->sh_size
, 1,
2250 return write_shdrs_and_ehdr (abfd
);
2253 /* Given an index of a section, retrieve a pointer to it. Note
2254 that for our purposes, sections are indexed by {1, 2, ...} with
2255 0 being an illegal index. */
2257 /* In the original, each ELF section went into exactly one BFD
2258 section. This doesn't really make sense, so we need a real mapping.
2259 The mapping has to hide in the Elf_Internal_Shdr since asection
2260 doesn't have anything like a tdata field... */
2263 DEFUN (section_from_elf_index
, (abfd
, index
),
2267 /* @@ Is bfd_com_section really correct in all the places it could
2268 be returned from this routine? */
2270 if (index
== SHN_ABS
)
2271 return &bfd_com_section
; /* not abs? */
2272 if (index
== SHN_COMMON
)
2273 return &bfd_com_section
;
2275 if (index
> elf_elfheader (abfd
)->e_shnum
)
2279 Elf_Internal_Shdr
*hdr
= elf_elfsections (abfd
)[index
];
2281 switch (hdr
->sh_type
)
2283 /* ELF sections that map to BFD sections */
2287 bfd_section_from_shdr (abfd
, index
);
2288 return (struct sec
*) hdr
->rawdata
;
2291 return (struct sec
*) &bfd_abs_section
;
2296 /* given a section, search the header to find them... */
2298 DEFUN (elf_section_from_bfd_section
, (abfd
, asect
),
2302 Elf_Internal_Shdr
**i_shdrp
= elf_elfsections (abfd
);
2304 Elf_Internal_Shdr
*hdr
;
2305 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2307 if (asect
== &bfd_abs_section
)
2309 if (asect
== &bfd_com_section
)
2311 if (asect
== &bfd_und_section
)
2314 for (index
= 0; index
< maxindex
; index
++)
2316 hdr
= i_shdrp
[index
];
2317 switch (hdr
->sh_type
)
2319 /* ELF sections that map to BFD sections */
2325 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2331 /* fix_up_strtabs will generate STRTAB sections with names
2333 if (!strncmp (asect
->name
, ".stab", 5)
2334 && !strcmp ("str", asect
->name
+ strlen (asect
->name
) - 3))
2338 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2346 struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
2348 if (bed
->elf_backend_section_from_bfd_section
)
2353 if ((*bed
->elf_backend_section_from_bfd_section
)
2354 (abfd
, hdr
, asect
, &retval
))
2364 /* given a symbol, return the bfd index for that symbol. */
2366 DEFUN (elf_symbol_from_bfd_symbol
, (abfd
, asym_ptr_ptr
),
2368 struct symbol_cache_entry
**asym_ptr_ptr
)
2370 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2372 flagword flags
= asym_ptr
->flags
;
2374 /* When gas creates relocations against local labels, it creates its
2375 own symbol for the section, but does put the symbol into the
2376 symbol chain, so udata is 0. When the linker is generating
2377 relocatable output, this section symbol may be for one of the
2378 input sections rather than the output section. */
2379 if (asym_ptr
->udata
== (PTR
) 0
2380 && (flags
& BSF_SECTION_SYM
)
2381 && asym_ptr
->section
)
2385 if (asym_ptr
->section
->output_section
!= NULL
)
2386 indx
= asym_ptr
->section
->output_section
->index
;
2388 indx
= asym_ptr
->section
->index
;
2389 if (elf_section_syms (abfd
)[indx
])
2390 asym_ptr
->udata
= elf_section_syms (abfd
)[indx
]->udata
;
2393 if (asym_ptr
->udata
)
2394 idx
= ((Elf_Sym_Extra
*)asym_ptr
->udata
)->elf_sym_num
;
2404 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx %s\n",
2405 (long) asym_ptr
, asym_ptr
->name
, idx
, flags
, elf_symbol_flags (flags
));
2414 DEFUN (elf_slurp_symbol_table
, (abfd
, symptrs
),
2416 asymbol
** symptrs
) /* Buffer for generated bfd symbols */
2418 Elf_Internal_Shdr
*hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2419 int symcount
; /* Number of external ELF symbols */
2421 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2422 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2423 Elf_Internal_Sym i_sym
;
2424 Elf_External_Sym
*x_symp
;
2426 /* this is only valid because there is only one symtab... */
2427 /* FIXME: This is incorrect, there may also be a dynamic symbol
2428 table which is a subset of the full symbol table. We either need
2429 to be prepared to read both (and merge them) or ensure that we
2430 only read the full symbol table. Currently we only get called to
2431 read the full symbol table. -fnf */
2432 if (bfd_get_outsymbols (abfd
) != NULL
)
2437 /* Read each raw ELF symbol, converting from external ELF form to
2438 internal ELF form, and then using the information to create a
2439 canonical bfd symbol table entry.
2441 Note that we allocate the initial bfd canonical symbol buffer
2442 based on a one-to-one mapping of the ELF symbols to canonical
2443 symbols. We actually use all the ELF symbols, so there will be no
2444 space left over at the end. When we have all the symbols, we
2445 build the caller's pointer vector. */
2447 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2449 bfd_error
= system_call_error
;
2453 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2454 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
));
2457 /* Temporarily allocate room for the raw ELF symbols. */
2458 x_symp
= (Elf_External_Sym
*) bfd_xmalloc (symcount
* sizeof (Elf_External_Sym
));
2460 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2461 != symcount
* sizeof (Elf_External_Sym
))
2463 free ((PTR
) x_symp
);
2464 bfd_error
= system_call_error
;
2467 /* Skip first symbol, which is a null dummy. */
2468 for (i
= 1; i
< symcount
; i
++)
2470 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2471 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2472 #ifdef ELF_KEEP_EXTSYM
2473 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2475 sym
->symbol
.the_bfd
= abfd
;
2477 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2480 sym
->symbol
.value
= i_sym
.st_value
;
2482 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
2484 sym
->symbol
.section
= section_from_elf_index (abfd
, i_sym
.st_shndx
);
2486 else if (i_sym
.st_shndx
== SHN_ABS
)
2488 sym
->symbol
.section
= &bfd_abs_section
;
2490 else if (i_sym
.st_shndx
== SHN_COMMON
)
2492 sym
->symbol
.section
= &bfd_com_section
;
2493 /* Elf puts the alignment into the `value' field, and the size
2494 into the `size' field. BFD wants to see the size in the
2495 value field, and doesn't care (at the moment) about the
2497 sym
->symbol
.value
= i_sym
.st_size
;
2499 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2501 sym
->symbol
.section
= &bfd_und_section
;
2504 sym
->symbol
.section
= &bfd_abs_section
;
2506 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2508 switch (ELF_ST_BIND (i_sym
.st_info
))
2511 sym
->symbol
.flags
|= BSF_LOCAL
;
2514 sym
->symbol
.flags
|= BSF_GLOBAL
;
2517 sym
->symbol
.flags
|= BSF_WEAK
;
2521 switch (ELF_ST_TYPE (i_sym
.st_info
))
2524 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2527 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2530 sym
->symbol
.flags
|= BSF_FUNCTION
;
2534 /* Do some backend-specific processing on this symbol. */
2536 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2537 if (ebd
->elf_backend_symbol_processing
)
2538 (*ebd
->elf_backend_symbol_processing
) (abfd
, &sym
->symbol
);
2544 /* Do some backend-specific processing on this symbol table. */
2546 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2547 if (ebd
->elf_backend_symbol_table_processing
)
2548 (*ebd
->elf_backend_symbol_table_processing
) (abfd
, symbase
, symcount
);
2551 /* We rely on the zalloc to clear out the final symbol entry. */
2553 bfd_get_symcount (abfd
) = symcount
= sym
- symbase
;
2555 /* Fill in the user's symbol pointer vector if needed. */
2559 while (symcount
-- > 0)
2561 *symptrs
++ = &sym
->symbol
;
2564 *symptrs
= 0; /* Final null pointer */
2570 /* Return the number of bytes required to hold the symtab vector.
2572 Note that we base it on the count plus 1, since we will null terminate
2573 the vector allocated based on this size. However, the ELF symbol table
2574 always has a dummy entry as symbol #0, so it ends up even. */
2577 DEFUN (elf_get_symtab_upper_bound
, (abfd
), bfd
* abfd
)
2579 unsigned int symcount
;
2580 unsigned int symtab_size
= 0;
2582 Elf_Internal_Shdr
*hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2583 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2584 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
));
2590 This function return the number of bytes required to store the
2591 relocation information associated with section <<sect>>
2592 attached to bfd <<abfd>>
2596 elf_get_reloc_upper_bound (abfd
, asect
)
2600 if (asect
->flags
& SEC_RELOC
)
2602 /* either rel or rela */
2603 return elf_section_data(asect
)->rel_hdr
.sh_size
;
2610 DEFUN (elf_slurp_reloca_table
, (abfd
, asect
, symbols
),
2615 Elf_External_Rela
*native_relocs
;
2616 arelent
*reloc_cache
;
2621 if (asect
->relocation
)
2623 if (asect
->reloc_count
== 0)
2625 if (asect
->flags
& SEC_CONSTRUCTOR
)
2628 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2629 native_relocs
= (Elf_External_Rela
*)
2630 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2631 bfd_read ((PTR
) native_relocs
,
2632 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
);
2634 reloc_cache
= (arelent
*)
2635 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2639 bfd_error
= no_memory
;
2643 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2645 Elf_Internal_Rela dst
;
2646 Elf_External_Rela
*src
;
2648 cache_ptr
= reloc_cache
+ idx
;
2649 src
= native_relocs
+ idx
;
2650 elf_swap_reloca_in (abfd
, src
, &dst
);
2652 #ifdef RELOC_PROCESSING
2653 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2655 if (asect
->flags
& SEC_RELOC
)
2657 /* relocatable, so the offset is off of the section */
2658 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2662 /* non-relocatable, so the offset a virtual address */
2663 cache_ptr
->address
= dst
.r_offset
;
2666 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2667 of zero points to the dummy symbol, which was not read into
2668 the symbol table SYMBOLS. */
2669 if (ELF_R_SYM (dst
.r_info
) == 0)
2670 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2675 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2677 /* Translate any ELF section symbol into a BFD section
2679 s
= *(cache_ptr
->sym_ptr_ptr
);
2680 if (s
->flags
& BSF_SECTION_SYM
)
2682 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2683 s
= *cache_ptr
->sym_ptr_ptr
;
2684 if (s
->name
== 0 || s
->name
[0] == 0)
2688 cache_ptr
->addend
= dst
.r_addend
;
2690 /* Fill in the cache_ptr->howto field from dst.r_type */
2692 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2693 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2698 asect
->relocation
= reloc_cache
;
2704 elf_debug_section (str
, num
, hdr
)
2707 Elf_Internal_Shdr
*hdr
;
2709 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
2711 "sh_name = %ld\tsh_type = %ld\tsh_flags = %ld\n",
2712 (long) hdr
->sh_name
,
2713 (long) hdr
->sh_type
,
2714 (long) hdr
->sh_flags
);
2716 "sh_addr = %ld\tsh_offset = %ld\tsh_size = %ld\n",
2717 (long) hdr
->sh_addr
,
2718 (long) hdr
->sh_offset
,
2719 (long) hdr
->sh_size
);
2721 "sh_link = %ld\tsh_info = %ld\tsh_addralign = %ld\n",
2722 (long) hdr
->sh_link
,
2723 (long) hdr
->sh_info
,
2724 (long) hdr
->sh_addralign
);
2725 fprintf (stderr
, "sh_entsize = %ld\n",
2726 (long) hdr
->sh_entsize
);
2727 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
2728 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
2729 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
2734 elf_debug_file (ehdrp
)
2735 Elf_Internal_Ehdr
*ehdrp
;
2737 fprintf (stderr
, "e_entry = 0x%.8lx\n", (long) ehdrp
->e_entry
);
2738 fprintf (stderr
, "e_phoff = %ld\n", (long) ehdrp
->e_phoff
);
2739 fprintf (stderr
, "e_phnum = %ld\n", (long) ehdrp
->e_phnum
);
2740 fprintf (stderr
, "e_phentsize = %ld\n", (long) ehdrp
->e_phentsize
);
2741 fprintf (stderr
, "e_shoff = %ld\n", (long) ehdrp
->e_shoff
);
2742 fprintf (stderr
, "e_shnum = %ld\n", (long) ehdrp
->e_shnum
);
2743 fprintf (stderr
, "e_shentsize = %ld\n", (long) ehdrp
->e_shentsize
);
2748 DEFUN (elf_slurp_reloc_table
, (abfd
, asect
, symbols
),
2753 Elf_External_Rel
*native_relocs
;
2754 arelent
*reloc_cache
;
2756 Elf_Internal_Shdr
*data_hdr
;
2757 ElfNAME (Off
) data_off
;
2758 ElfNAME (Word
) data_max
;
2759 char buf
[4]; /* FIXME -- might be elf64 */
2763 if (asect
->relocation
)
2765 if (asect
->reloc_count
== 0)
2767 if (asect
->flags
& SEC_CONSTRUCTOR
)
2770 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2771 native_relocs
= (Elf_External_Rel
*)
2772 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
2773 bfd_read ((PTR
) native_relocs
,
2774 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
);
2776 reloc_cache
= (arelent
*)
2777 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2781 bfd_error
= no_memory
;
2785 /* Get the offset of the start of the segment we are relocating to read in
2786 the implicit addend. */
2787 data_hdr
= &elf_section_data(asect
)->this_hdr
;
2788 data_off
= data_hdr
->sh_offset
;
2789 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
2792 elf_debug_section ("data section", -1, data_hdr
);
2795 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2797 #ifdef RELOC_PROCESSING
2798 Elf_Internal_Rel dst
;
2799 Elf_External_Rel
*src
;
2801 cache_ptr
= reloc_cache
+ idx
;
2802 src
= native_relocs
+ idx
;
2803 elf_swap_reloc_in (abfd
, src
, &dst
);
2805 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2807 Elf_Internal_Rel dst
;
2808 Elf_External_Rel
*src
;
2810 cache_ptr
= reloc_cache
+ idx
;
2811 src
= native_relocs
+ idx
;
2813 elf_swap_reloc_in (abfd
, src
, &dst
);
2815 if (asect
->flags
& SEC_RELOC
)
2817 /* relocatable, so the offset is off of the section */
2818 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2822 /* non-relocatable, so the offset a virtual address */
2823 cache_ptr
->address
= dst
.r_offset
;
2826 /* ELF_R_SYM(dst.r_info) is the symbol table offset. An offset
2827 of zero points to the dummy symbol, which was not read into
2828 the symbol table SYMBOLS. */
2829 if (ELF_R_SYM (dst
.r_info
) == 0)
2830 cache_ptr
->sym_ptr_ptr
= bfd_abs_section
.symbol_ptr_ptr
;
2835 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM (dst
.r_info
) - 1;
2837 /* Translate any ELF section symbol into a BFD section
2839 s
= *(cache_ptr
->sym_ptr_ptr
);
2840 if (s
->flags
& BSF_SECTION_SYM
)
2842 cache_ptr
->sym_ptr_ptr
= s
->section
->symbol_ptr_ptr
;
2843 s
= *cache_ptr
->sym_ptr_ptr
;
2844 if (s
->name
== 0 || s
->name
[0] == 0)
2848 BFD_ASSERT (dst
.r_offset
<= data_max
);
2849 cache_ptr
->addend
= 0;
2851 /* Fill in the cache_ptr->howto field from dst.r_type */
2853 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2854 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
2859 asect
->relocation
= reloc_cache
;
2864 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2870 arelent
*tblptr
= section
->relocation
;
2871 unsigned int count
= 0;
2872 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
2874 /* snarfed from coffcode.h */
2876 elf_slurp_reloca_table (abfd
, section
, symbols
);
2878 elf_slurp_reloc_table (abfd
, section
, symbols
);
2880 tblptr
= section
->relocation
;
2884 for (; count
++ < section
->reloc_count
;)
2885 *relptr
++ = tblptr
++;
2888 return section
->reloc_count
;
2892 DEFUN (elf_get_symtab
, (abfd
, alocation
),
2894 asymbol
** alocation
)
2897 if (!elf_slurp_symbol_table (abfd
, alocation
))
2900 return bfd_get_symcount (abfd
);
2904 DEFUN (elf_make_empty_symbol
, (abfd
),
2907 elf_symbol_type
*newsym
;
2909 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
2912 bfd_error
= no_memory
;
2917 newsym
->symbol
.the_bfd
= abfd
;
2918 return &newsym
->symbol
;
2923 DEFUN (elf_get_symbol_info
, (ignore_abfd
, symbol
, ret
),
2924 bfd
* ignore_abfd AND
2925 asymbol
* symbol AND
2928 bfd_symbol_info (symbol
, ret
);
2932 DEFUN (elf_print_symbol
, (ignore_abfd
, filep
, symbol
, how
),
2933 bfd
* ignore_abfd AND
2935 asymbol
* symbol AND
2936 bfd_print_symbol_type how
)
2938 FILE *file
= (FILE *) filep
;
2941 case bfd_print_symbol_name
:
2942 fprintf (file
, "%s", symbol
->name
);
2944 case bfd_print_symbol_more
:
2945 fprintf (file
, "elf ");
2946 fprintf_vma (file
, symbol
->value
);
2947 fprintf (file
, " %lx", (long) symbol
->flags
);
2949 case bfd_print_symbol_all
:
2951 CONST
char *section_name
;
2952 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
2953 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
2954 fprintf (file
, " %s\t%s",
2964 DEFUN (elf_get_lineno
, (ignore_abfd
, symbol
),
2965 bfd
* ignore_abfd AND
2968 fprintf (stderr
, "elf_get_lineno unimplemented\n");
2975 DEFUN (elf_set_arch_mach
, (abfd
, arch
, machine
),
2977 enum bfd_architecture arch AND
2978 unsigned long machine
)
2980 /* Allow any architecture to be supported by the elf backend */
2983 case bfd_arch_unknown
: /* EM_NONE */
2984 case bfd_arch_sparc
: /* EM_SPARC */
2985 case bfd_arch_i386
: /* EM_386 */
2986 case bfd_arch_m68k
: /* EM_68K */
2987 case bfd_arch_m88k
: /* EM_88K */
2988 case bfd_arch_i860
: /* EM_860 */
2989 case bfd_arch_mips
: /* EM_MIPS (MIPS R3000) */
2990 case bfd_arch_hppa
: /* EM_HPPA (HP PA_RISC) */
2991 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
2998 DEFUN (elf_find_nearest_line
, (abfd
,
3006 asection
* section AND
3007 asymbol
** symbols AND
3009 CONST
char **filename_ptr AND
3010 CONST
char **functionname_ptr AND
3011 unsigned int *line_ptr
)
3017 DEFUN (elf_sizeof_headers
, (abfd
, reloc
),
3021 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
3028 DEFUN (elf_set_section_contents
, (abfd
, section
, location
, offset
, count
),
3033 bfd_size_type count
)
3035 Elf_Internal_Shdr
*hdr
;
3037 if (abfd
->output_has_begun
== false) /* set by bfd.c handler? */
3039 /* do setup calculations (FIXME) */
3040 prep_headers (abfd
);
3041 elf_compute_section_file_positions (abfd
);
3042 abfd
->output_has_begun
= true;
3045 hdr
= &elf_section_data(section
)->this_hdr
;
3047 if (bfd_seek (abfd
, hdr
->sh_offset
+ offset
, SEEK_SET
) == -1)
3049 if (bfd_write (location
, 1, count
, abfd
) != count
)
3056 DEFUN (elf_no_info_to_howto
, (abfd
, cache_ptr
, dst
),
3058 arelent
* cache_ptr AND
3059 Elf_Internal_Rela
* dst
)
3061 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3067 DEFUN (elf_no_info_to_howto_rel
, (abfd
, cache_ptr
, dst
),
3069 arelent
* cache_ptr AND
3070 Elf_Internal_Rel
* dst
)
3072 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3078 /* Core file support */
3080 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
3081 #include <sys/procfs.h>
3083 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
3084 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
3085 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
3091 DEFUN (bfd_prstatus
, (abfd
, descdata
, descsz
, filepos
),
3098 prstatus_t
*status
= (prstatus_t
*) 0;
3100 if (descsz
== sizeof (prstatus_t
))
3102 newsect
= bfd_make_section (abfd
, ".reg");
3103 newsect
->_raw_size
= sizeof (status
->pr_reg
);
3104 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
3105 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3106 newsect
->alignment_power
= 2;
3107 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3109 memcpy (core_prstatus (abfd
), descdata
, descsz
);
3114 /* Stash a copy of the prpsinfo structure away for future use. */
3117 DEFUN (bfd_prpsinfo
, (abfd
, descdata
, descsz
, filepos
),
3125 if (descsz
== sizeof (prpsinfo_t
))
3127 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
3129 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
3135 DEFUN (bfd_fpregset
, (abfd
, descdata
, descsz
, filepos
),
3143 newsect
= bfd_make_section (abfd
, ".reg2");
3144 newsect
->_raw_size
= descsz
;
3145 newsect
->filepos
= filepos
;
3146 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3147 newsect
->alignment_power
= 2;
3150 #endif /* HAVE_PROCFS */
3152 /* Return a pointer to the args (including the command name) that were
3153 seen by the program that generated the core dump. Note that for
3154 some reason, a spurious space is tacked onto the end of the args
3155 in some (at least one anyway) implementations, so strip it off if
3159 DEFUN (elf_core_file_failing_command
, (abfd
),
3163 if (core_prpsinfo (abfd
))
3165 prpsinfo_t
*p
= core_prpsinfo (abfd
);
3166 char *scan
= p
->pr_psargs
;
3171 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
3175 return p
->pr_psargs
;
3181 /* Return the number of the signal that caused the core dump. Presumably,
3182 since we have a core file, we got a signal of some kind, so don't bother
3183 checking the other process status fields, just return the signal number.
3187 DEFUN (elf_core_file_failing_signal
, (abfd
),
3191 if (core_prstatus (abfd
))
3193 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
3199 /* Check to see if the core file could reasonably be expected to have
3200 come for the current executable file. Note that by default we return
3201 true unless we find something that indicates that there might be a
3206 DEFUN (elf_core_file_matches_executable_p
, (core_bfd
, exec_bfd
),
3215 /* First, xvecs must match since both are ELF files for the same target. */
3217 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
3219 bfd_error
= system_call_error
;
3225 /* If no prpsinfo, just return true. Otherwise, grab the last component
3226 of the exec'd pathname from the prpsinfo. */
3228 if (core_prpsinfo (core_bfd
))
3230 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
3237 /* Find the last component of the executable pathname. */
3239 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
3245 execname
= (char *) exec_bfd
->filename
;
3248 /* See if they match */
3250 return strcmp (execname
, corename
) ? false : true;
3256 #endif /* HAVE_PROCFS */
3259 /* ELF core files contain a segment of type PT_NOTE, that holds much of
3260 the information that would normally be available from the /proc interface
3261 for the process, at the time the process dumped core. Currently this
3262 includes copies of the prstatus, prpsinfo, and fpregset structures.
3264 Since these structures are potentially machine dependent in size and
3265 ordering, bfd provides two levels of support for them. The first level,
3266 available on all machines since it does not require that the host
3267 have /proc support or the relevant include files, is to create a bfd
3268 section for each of the prstatus, prpsinfo, and fpregset structures,
3269 without any interpretation of their contents. With just this support,
3270 the bfd client will have to interpret the structures itself. Even with
3271 /proc support, it might want these full structures for it's own reasons.
3273 In the second level of support, where HAVE_PROCFS is defined, bfd will
3274 pick apart the structures to gather some additional information that
3275 clients may want, such as the general register set, the name of the
3276 exec'ed file and its arguments, the signal (if any) that caused the
3282 DEFUN (elf_corefile_note
, (abfd
, hdr
),
3284 Elf_Internal_Phdr
* hdr
)
3286 Elf_External_Note
*x_note_p
; /* Elf note, external form */
3287 Elf_Internal_Note i_note
; /* Elf note, internal form */
3288 char *buf
= NULL
; /* Entire note segment contents */
3289 char *namedata
; /* Name portion of the note */
3290 char *descdata
; /* Descriptor portion of the note */
3291 char *sectname
; /* Name to use for new section */
3292 long filepos
; /* File offset to descriptor data */
3295 if (hdr
->p_filesz
> 0
3296 && (buf
= (char *) bfd_xmalloc (hdr
->p_filesz
)) != NULL
3297 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
3298 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
3300 x_note_p
= (Elf_External_Note
*) buf
;
3301 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
3303 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
3304 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
3305 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
3306 namedata
= x_note_p
->name
;
3307 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
3308 filepos
= hdr
->p_offset
+ (descdata
- buf
);
3309 switch (i_note
.type
)
3312 /* process descdata as prstatus info */
3313 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
3314 sectname
= ".prstatus";
3317 /* process descdata as fpregset info */
3318 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
3319 sectname
= ".fpregset";
3322 /* process descdata as prpsinfo */
3323 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
3324 sectname
= ".prpsinfo";
3327 /* Unknown descriptor, just ignore it. */
3331 if (sectname
!= NULL
)
3333 newsect
= bfd_make_section (abfd
, sectname
);
3334 newsect
->_raw_size
= i_note
.descsz
;
3335 newsect
->filepos
= filepos
;
3336 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
3337 newsect
->alignment_power
= 2;
3339 x_note_p
= (Elf_External_Note
*)
3340 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
3351 /* Core files are simply standard ELF formatted files that partition
3352 the file using the execution view of the file (program header table)
3353 rather than the linking view. In fact, there is no section header
3354 table in a core file.
3356 The process status information (including the contents of the general
3357 register set) and the floating point register set are stored in a
3358 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
3359 that allow standard bfd access to the general registers (.reg) and the
3360 floating point registers (.reg2).
3365 DEFUN (elf_core_file_p
, (abfd
), bfd
* abfd
)
3367 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
3368 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
3369 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
3370 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
3371 unsigned int phindex
;
3373 /* Read in the ELF header in external format. */
3375 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
3377 bfd_error
= system_call_error
;
3381 /* Now check to see if we have a valid ELF file, and one that BFD can
3382 make use of. The magic number must match, the address size ('class')
3383 and byte-swapping must match our XVEC entry, and it must have a
3384 program header table (FIXME: See comments re segments at top of this
3387 if (elf_file_p (&x_ehdr
) == false)
3390 bfd_error
= wrong_format
;
3394 /* FIXME, Check EI_VERSION here ! */
3398 int desired_address_size
= ELFCLASS32
;
3401 int desired_address_size
= ELFCLASS64
;
3404 if (x_ehdr
.e_ident
[EI_CLASS
] != desired_address_size
)
3408 /* Switch xvec to match the specified byte order. */
3409 switch (x_ehdr
.e_ident
[EI_DATA
])
3411 case ELFDATA2MSB
: /* Big-endian */
3412 if (abfd
->xvec
->byteorder_big_p
== false)
3415 case ELFDATA2LSB
: /* Little-endian */
3416 if (abfd
->xvec
->byteorder_big_p
== true)
3419 case ELFDATANONE
: /* No data encoding specified */
3420 default: /* Unknown data encoding specified */
3424 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
3425 the tdata pointer in the bfd. */
3428 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
3429 if (elf_tdata (abfd
) == NULL
)
3431 bfd_error
= no_memory
;
3435 /* FIXME, `wrong' returns from this point onward, leak memory. */
3437 /* Now that we know the byte order, swap in the rest of the header */
3438 i_ehdrp
= elf_elfheader (abfd
);
3439 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
3441 elf_debug_file (i_ehdrp
);
3444 /* If there is no program header, or the type is not a core file, then
3446 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
3449 /* Allocate space for a copy of the program header table in
3450 internal form, seek to the program header table in the file,
3451 read it in, and convert it to internal form. As a simple sanity
3452 check, verify that the what BFD thinks is the size of each program
3453 header table entry actually matches the size recorded in the file. */
3455 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
3457 i_phdrp
= (Elf_Internal_Phdr
*)
3458 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
3461 bfd_error
= no_memory
;
3464 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
3466 bfd_error
= system_call_error
;
3469 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3471 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
3474 bfd_error
= system_call_error
;
3477 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
3480 /* Once all of the program headers have been read and converted, we
3481 can start processing them. */
3483 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
3485 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
3486 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
3488 elf_corefile_note (abfd
, i_phdrp
+ phindex
);
3492 /* Remember the entry point specified in the ELF file header. */
3494 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;