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. */
33 /* Problems and other issues to resolve.
35 (1) BFD expects there to be some fixed number of "sections" in
36 the object file. I.E. there is a "section_count" variable in the
37 bfd structure which contains the number of sections. However, ELF
38 supports multiple "views" of a file. In particular, with current
39 implementations, executable files typically have two tables, a
40 program header table and a section header table, both of which
41 partition the executable.
43 In ELF-speak, the "linking view" of the file uses the section header
44 table to access "sections" within the file, and the "execution view"
45 uses the program header table to access "segments" within the file.
46 "Segments" typically may contain all the data from one or more
49 Note that the section header table is optional in ELF executables,
50 but it is this information that is most useful to gdb. If the
51 section header table is missing, then gdb should probably try
52 to make do with the program header table. (FIXME)
56 #include <string.h> /* For strrchr and friends */
62 #define Elf_External_Ehdr NAME(Elf,External_Ehdr)
63 #define Elf_Internal_Ehdr NAME(Elf,Internal_Ehdr)
64 #define Elf_External_Sym NAME(Elf,External_Sym)
65 #define Elf_Internal_Sym NAME(Elf,Internal_Sym)
66 #define Elf_External_Shdr NAME(Elf,External_Shdr)
67 #define Elf_Internal_Shdr NAME(Elf,Internal_Shdr)
68 #define Elf_External_Phdr NAME(Elf,External_Phdr)
69 #define Elf_Internal_Phdr NAME(Elf,Internal_Phdr)
70 #define Elf_External_Rel NAME(Elf,External_Rel)
71 #define Elf_External_Rela NAME(Elf,External_Rela)
72 #define Elf_Internal_Rel NAME(Elf,Internal_Rel)
73 #define Elf_Internal_Rela NAME(Elf,Internal_Rela)
75 #define elf_symbol_type NAME(elf,symbol_type)
76 #define elf_internal_shdr NAME(elf,internal_shdr)
77 #define elf_backend_data NAME(elf,backend_data)
79 #define elf_core_file_failing_command NAME(bfd_elf,core_file_failing_command)
80 #define elf_core_file_failing_signal NAME(bfd_elf,core_file_failing_signal)
81 #define elf_core_file_matches_executable_p NAME(bfd_elf,core_file_matches_executable_p)
82 #define elf_object_p NAME(bfd_elf,object_p)
83 #define elf_core_file_p NAME(bfd_elf,core_file_p)
84 #define elf_mkobject NAME(bfd_elf,mkobject)
85 #define elf_write_object_contents NAME(bfd_elf,write_object_contents)
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_get_sect_thunk NAME(bfd_elf,get_sect_thunk)
101 #define elf_hash NAME(bfd_elf,hash)
104 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
105 #include <sys/procfs.h>
107 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
108 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
109 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
114 #define INLINE __inline__
120 /* Forward declarations of static functions */
122 static char * elf_read
PARAMS ((bfd
*, long, int));
124 static struct sec
* section_from_elf_index
PARAMS ((bfd
*, int));
126 static int elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
128 static boolean elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**));
130 static char * elf_get_str_section
PARAMS ((bfd
*, unsigned int));
132 static int elf_symbol_from_bfd_symbol
PARAMS ((bfd
*,
133 struct symbol_cache_entry
**));
135 static boolean elf_map_symbols
PARAMS ((bfd
*));
137 /* Some private data is stashed away for future use using the tdata pointer
138 in the bfd structure. */
142 Elf_Internal_Ehdr elf_header
[1]; /* Actual data, but ref like ptr */
143 Elf_Internal_Shdr
*elf_sect_ptr
;
144 struct strtab
*strtab_ptr
;
149 void *prstatus
; /* The raw /proc prstatus structure */
150 void *prpsinfo
; /* The raw /proc prpsinfo structure */
151 Elf_External_Sym
*raw_syms
;
152 Elf_Internal_Sym
*internal_syms
;
153 elf_symbol_type
*symbols
;
156 #define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data)
157 #define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header)
158 #define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr)
159 #define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr)
160 #define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section)
161 #define elf_num_locals(bfd) (elf_tdata(bfd) -> num_locals)
162 #define elf_num_globals(bfd) (elf_tdata(bfd) -> num_globals)
163 #define elf_symtab_map(bfd) (elf_tdata(bfd) -> symtab_map)
164 #define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo)
165 #define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus)
166 #define obj_symbols(bfd) (elf_tdata(bfd) -> symbols)
167 #define obj_raw_syms(bfd) (elf_tdata(bfd) -> raw_syms)
168 #define obj_internal_syms(bfd) (elf_tdata(bfd) -> internal_syms)
170 /* Translate an ELF symbol in external format into an ELF symbol in internal
174 DEFUN (elf_swap_symbol_in
, (abfd
, src
, dst
),
176 Elf_External_Sym
* src AND
177 Elf_Internal_Sym
* dst
)
179 dst
->st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_name
);
180 dst
->st_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_value
);
181 dst
->st_size
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->st_size
);
182 dst
->st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_info
);
183 dst
->st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
->st_other
);
184 dst
->st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->st_shndx
);
187 /* Translate an ELF symbol in internal format into an ELF symbol in external
191 DEFUN (elf_swap_symbol_out
, (abfd
, src
, dst
),
193 Elf_Internal_Sym
* src AND
194 Elf_External_Sym
* dst
)
196 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
197 bfd_h_put_32 (abfd
, src
->st_value
, dst
->st_value
);
198 bfd_h_put_32 (abfd
, src
->st_size
, dst
->st_size
);
199 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
200 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
201 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
205 /* Translate an ELF file header in external format into an ELF file header in
209 DEFUN (elf_swap_ehdr_in
, (abfd
, src
, dst
),
211 Elf_External_Ehdr
* src AND
212 Elf_Internal_Ehdr
* dst
)
214 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
215 dst
->e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_type
);
216 dst
->e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_machine
);
217 dst
->e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_version
);
218 dst
->e_entry
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_entry
);
219 dst
->e_phoff
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_phoff
);
220 dst
->e_shoff
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_shoff
);
221 dst
->e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->e_flags
);
222 dst
->e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_ehsize
);
223 dst
->e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phentsize
);
224 dst
->e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_phnum
);
225 dst
->e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shentsize
);
226 dst
->e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shnum
);
227 dst
->e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
->e_shstrndx
);
230 /* Translate an ELF file header in internal format into an ELF file header in
234 DEFUN (elf_swap_ehdr_out
, (abfd
, src
, dst
),
236 Elf_Internal_Ehdr
* src AND
237 Elf_External_Ehdr
* dst
)
239 memcpy (dst
->e_ident
, src
->e_ident
, EI_NIDENT
);
240 /* note that all elements of dst are *arrays of unsigned char* already... */
241 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
242 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
243 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
244 bfd_h_put_32 (abfd
, src
->e_entry
, dst
->e_entry
);
245 bfd_h_put_32 (abfd
, src
->e_phoff
, dst
->e_phoff
);
246 bfd_h_put_32 (abfd
, src
->e_shoff
, dst
->e_shoff
);
247 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
248 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
249 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
250 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
251 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
252 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
253 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
257 /* Translate an ELF section header table entry in external format into an
258 ELF section header table entry in internal format. */
261 DEFUN (elf_swap_shdr_in
, (abfd
, src
, dst
),
263 Elf_External_Shdr
* src AND
264 Elf_Internal_Shdr
* dst
)
266 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
267 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
268 dst
->sh_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_flags
);
269 dst
->sh_addr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_addr
);
270 dst
->sh_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_offset
);
271 dst
->sh_size
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_size
);
272 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
273 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
274 dst
->sh_addralign
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_addralign
);
275 dst
->sh_entsize
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_entsize
);
276 /* we haven't done any processing on it yet, so... */
277 dst
->rawdata
= (void *) 0;
280 /* Translate an ELF section header table entry in internal format into an
281 ELF section header table entry in external format. */
284 DEFUN (elf_swap_shdr_out
, (abfd
, src
, dst
),
286 Elf_Internal_Shdr
* src AND
287 Elf_External_Shdr
* dst
)
289 /* note that all elements of dst are *arrays of unsigned char* already... */
290 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
291 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
292 bfd_h_put_32 (abfd
, src
->sh_flags
, dst
->sh_flags
);
293 bfd_h_put_32 (abfd
, src
->sh_addr
, dst
->sh_addr
);
294 bfd_h_put_32 (abfd
, src
->sh_offset
, dst
->sh_offset
);
295 bfd_h_put_32 (abfd
, src
->sh_size
, dst
->sh_size
);
296 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
297 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
298 bfd_h_put_32 (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
299 bfd_h_put_32 (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
303 /* Translate an ELF program header table entry in external format into an
304 ELF program header table entry in internal format. */
307 DEFUN (elf_swap_phdr_in
, (abfd
, src
, dst
),
309 Elf_External_Phdr
* src AND
310 Elf_Internal_Phdr
* dst
)
312 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
313 dst
->p_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_offset
);
314 dst
->p_vaddr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_vaddr
);
315 dst
->p_paddr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_paddr
);
316 dst
->p_filesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_filesz
);
317 dst
->p_memsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_memsz
);
318 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
319 dst
->p_align
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_align
);
325 DEFUN (elf_swap_phdr_out
, (abfd
, src
, dst
),
327 Elf_Internal_Phdr
* src AND
328 Elf_External_Phdr
* dst
)
330 /* note that all elements of dst are *arrays of unsigned char* already... */
331 bfd_h_put_32 (abfd
, src
->p_type
, dst
->p_type
);
332 bfd_h_put_32 (abfd
, src
->p_offset
, dst
->p_offset
);
333 bfd_h_put_32 (abfd
, src
->p_vaddr
, dst
->p_vaddr
);
334 bfd_h_put_32 (abfd
, src
->p_paddr
, dst
->p_paddr
);
335 bfd_h_put_32 (abfd
, src
->p_filesz
, dst
->p_filesz
);
336 bfd_h_put_32 (abfd
, src
->p_memsz
, dst
->p_memsz
);
337 bfd_h_put_32 (abfd
, src
->p_flags
, dst
->p_flags
);
338 bfd_h_put_32 (abfd
, src
->p_align
, dst
->p_align
);
341 /* Translate an ELF reloc from external format to internal format. */
343 DEFUN (elf_swap_reloc_in
, (abfd
, src
, dst
),
345 Elf_External_Rel
* src AND
346 Elf_Internal_Rel
* dst
)
348 dst
->r_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_offset
);
349 dst
->r_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_info
);
353 DEFUN (elf_swap_reloca_in
, (abfd
, src
, dst
),
355 Elf_External_Rela
* src AND
356 Elf_Internal_Rela
* dst
)
358 dst
->r_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_offset
);
359 dst
->r_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_info
);
360 dst
->r_addend
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_addend
);
363 /* Translate an ELF reloc from internal format to external format. */
365 DEFUN (elf_swap_reloc_out
, (abfd
, src
, dst
),
367 Elf_Internal_Rel
* src AND
368 Elf_External_Rel
* dst
)
370 bfd_h_put_32 (abfd
, src
->r_offset
, dst
->r_offset
);
371 bfd_h_put_32 (abfd
, src
->r_info
, dst
->r_info
);
375 DEFUN (elf_swap_reloca_out
, (abfd
, src
, dst
),
377 Elf_Internal_Rela
* src AND
378 Elf_External_Rela
* dst
)
380 bfd_h_put_32 (abfd
, src
->r_offset
, dst
->r_offset
);
381 bfd_h_put_32 (abfd
, src
->r_info
, dst
->r_info
);
382 bfd_h_put_32 (abfd
, src
->r_addend
, dst
->r_addend
);
390 struct elf32_internal_shdr *bfd_elf32_find_section (bfd *abfd, char *name);
393 Helper functions for GDB to locate the string tables.
394 Since BFD hides string tables from callers, GDB needs to use an
395 internal hook to find them. Sun's .stabstr, in particular,
396 isn't even pointed to by the .stab section, so ordinary
397 mechanisms wouldn't work to find it, even if we had some.
400 struct elf_internal_shdr
*
401 DEFUN (NAME (bfd_elf
,find_section
), (abfd
, name
),
405 Elf_Internal_Shdr
*i_shdrp
;
406 Elf_Internal_Shdr
*gotit
= NULL
;
411 i_shdrp
= elf_elfsections (abfd
);
414 shstrtab
= elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
415 if (shstrtab
!= NULL
)
417 max
= elf_elfheader (abfd
)->e_shnum
;
418 for (i
= 1; i
< max
; i
++)
420 if (!strcmp (&shstrtab
[i_shdrp
[i
].sh_name
], name
))
430 /* End of GDB support. */
433 DEFUN (elf_get_str_section
, (abfd
, shindex
),
435 unsigned int shindex
)
437 Elf_Internal_Shdr
*i_shdrp
;
438 char *shstrtab
= NULL
;
440 unsigned int shstrtabsize
;
442 i_shdrp
= elf_elfsections (abfd
);
445 shstrtab
= i_shdrp
[shindex
].rawdata
;
446 if (shstrtab
== NULL
)
448 /* No cached one, attempt to read, and cache what we read. */
449 offset
= i_shdrp
[shindex
].sh_offset
;
450 shstrtabsize
= i_shdrp
[shindex
].sh_size
;
451 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
452 i_shdrp
[shindex
].rawdata
= (void *) shstrtab
;
459 DEFUN (elf_string_from_elf_section
, (abfd
, shindex
, strindex
),
461 unsigned int shindex AND
462 unsigned int strindex
)
464 Elf_Internal_Shdr
*hdr
;
469 hdr
= elf_elfsections (abfd
) + shindex
;
472 && elf_get_str_section (abfd
, shindex
) == NULL
)
475 return ((char *) hdr
->rawdata
) + strindex
;
479 elf_string_from_elf_strtab (abfd
, strindex
)
483 return elf_string_from_elf_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
,
487 /* Create a new bfd section from an ELF section header. */
490 DEFUN (bfd_section_from_shdr
, (abfd
, shindex
),
492 unsigned int shindex
)
494 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
495 Elf_Internal_Shdr
*hdr
= i_shdrp
+ shindex
;
499 name
= elf_string_from_elf_strtab (abfd
, hdr
->sh_name
);
501 switch (hdr
->sh_type
)
505 /* inactive section. Throw it away. */
509 /* Bits that get saved. This one is real. */
512 newsect
= bfd_make_section (abfd
, name
);
515 newsect
->vma
= hdr
->sh_addr
;
516 newsect
->_raw_size
= hdr
->sh_size
;
517 newsect
->filepos
= hdr
->sh_offset
; /* so we can read back the bits */
518 newsect
->flags
|= SEC_HAS_CONTENTS
;
519 newsect
->alignment_power
= hdr
->sh_addralign
;
521 if (hdr
->sh_flags
& SHF_ALLOC
)
523 newsect
->flags
|= SEC_ALLOC
;
524 newsect
->flags
|= SEC_LOAD
;
527 if (!(hdr
->sh_flags
& SHF_WRITE
))
528 newsect
->flags
|= SEC_READONLY
;
530 if (hdr
->sh_flags
& SHF_EXECINSTR
)
531 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
533 newsect
->flags
|= SEC_DATA
;
535 hdr
->rawdata
= (void *) newsect
;
541 /* Bits that get saved. This one is real. */
544 newsect
= bfd_make_section (abfd
, name
);
547 newsect
->vma
= hdr
->sh_addr
;
548 newsect
->_raw_size
= hdr
->sh_size
;
549 newsect
->filepos
= hdr
->sh_offset
; /* fake */
550 newsect
->alignment_power
= hdr
->sh_addralign
;
551 if (hdr
->sh_flags
& SHF_ALLOC
)
552 newsect
->flags
|= SEC_ALLOC
;
554 if (!(hdr
->sh_flags
& SHF_WRITE
))
555 newsect
->flags
|= SEC_READONLY
;
557 if (hdr
->sh_flags
& SHF_EXECINSTR
)
558 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
560 newsect
->flags
|= SEC_DATA
;
562 hdr
->rawdata
= (void *) newsect
;
567 case SHT_SYMTAB
: /* A symbol table */
568 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
569 elf_onesymtab (abfd
) = shindex
;
570 abfd
->flags
|= HAS_SYMS
;
573 case SHT_STRTAB
: /* A string table */
578 /* *these* do a lot of work -- but build no sections! */
579 /* the spec says there can be multiple strtabs, but only one symtab */
580 /* but there can be lots of REL* sections. */
581 /* FIXME: The above statement is wrong! There are typically at least
582 two symbol tables in a dynamically linked executable, ".dynsym"
583 which is the dynamic linkage symbol table and ".symtab", which is
584 the "traditional" symbol table. -fnf */
587 asection
*target_sect
;
588 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
590 /* Don't allow REL relocations on a machine that uses RELA and
592 /* @@ Actually, the generic ABI does suggest that both might be
593 used in one file. But the four ABI Processor Supplements I
594 have access to right now all specify that only one is used on
595 each of those architectures. It's conceivable that, e.g., a
596 bunch of absolute 32-bit relocs might be more compact in REL
597 form even on a RELA machine... */
598 BFD_ASSERT (!(use_rela_p
&& (hdr
->sh_type
== SHT_REL
)));
599 BFD_ASSERT (!(!use_rela_p
&& (hdr
->sh_type
== SHT_RELA
)));
600 BFD_ASSERT (hdr
->sh_entsize
==
602 ? sizeof (Elf32_External_Rela
)
603 : sizeof (Elf32_External_Rel
)));
605 bfd_section_from_shdr (abfd
, hdr
->sh_link
); /* symbol table */
606 bfd_section_from_shdr (abfd
, hdr
->sh_info
); /* target */
607 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
608 if (target_sect
== NULL
)
612 /* FIXME: We are only prepared to read one symbol table, so
613 do NOT read the dynamic symbol table since it is only a
614 subset of the full symbol table. Also see comment above. -fnf */
615 if (!elf_slurp_symbol_table (abfd
, i_shdrp
+ hdr
->sh_link
))
619 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
620 target_sect
->flags
|= SEC_RELOC
;
621 target_sect
->relocation
= 0;
622 target_sect
->rel_filepos
= hdr
->sh_offset
;
629 case SHT_DYNSYM
: /* could treat this like symtab... */
631 fprintf (stderr
, "Dynamic Linking sections not yet supported.\n");
638 fprintf (stderr
, "Note Sections not yet supported.\n");
645 fprintf (stderr
, "SHLIB Sections not supported (and non conforming.)\n");
656 static struct strtab
*
657 DEFUN (bfd_new_strtab
, (abfd
),
662 ss
= (struct strtab
*) bfd_xmalloc (sizeof (struct strtab
));
663 ss
->tab
= bfd_xmalloc (1);
664 BFD_ASSERT (ss
->tab
!= 0);
673 DEFUN (bfd_add_to_strtab
, (abfd
, ss
, str
),
675 struct strtab
*ss AND
678 /* should search first, but for now: */
679 /* include the trailing NUL */
680 int ln
= strlen (str
) + 1;
682 /* should this be using obstacks? */
683 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
685 BFD_ASSERT (ss
->tab
!= 0);
686 strcpy (ss
->tab
+ ss
->length
, str
);
690 return ss
->length
- ln
;
694 DEFUN (bfd_add_2_to_strtab
, (abfd
, ss
, str
, str2
),
696 struct strtab
*ss AND
700 /* should search first, but for now: */
701 /* include the trailing NUL */
702 int ln
= strlen (str
) + strlen (str2
) + 1;
704 /* should this be using obstacks? */
706 ss
->tab
= realloc (ss
->tab
, ss
->length
+ ln
);
708 ss
->tab
= bfd_xmalloc (ln
);
710 BFD_ASSERT (ss
->tab
!= 0);
711 strcpy (ss
->tab
+ ss
->length
, str
);
712 strcpy (ss
->tab
+ ss
->length
+ strlen (str
), str2
);
716 return ss
->length
- ln
;
719 /* Create a new ELF section from a bfd section. */
722 DEFUN (bfd_shdr_from_section
, (abfd
, hdr
, shstrtab
, indx
),
724 Elf_Internal_Shdr
* hdr AND
725 struct strtab
*shstrtab AND
731 /* figure out out to write the section name from the bfd section name. MWE */
733 sect
= abfd
->sections
;
734 for (ndx
= indx
; --ndx
;)
738 hdr
[indx
].sh_name
= bfd_add_to_strtab (abfd
, shstrtab
,
739 bfd_section_name (abfd
, sect
));
740 hdr
[indx
].sh_addr
= sect
->vma
;
741 hdr
[indx
].sh_size
= sect
->_raw_size
;
742 hdr
[indx
].sh_addralign
= sect
->alignment_power
;
743 hdr
[indx
].sh_flags
= 0;
744 /* these need to be preserved on */
745 hdr
[indx
].sh_link
= 0;
746 hdr
[indx
].sh_info
= 0;
747 hdr
[indx
].sh_entsize
= 0;
749 hdr
[indx
].sh_type
= 0;
750 if (sect
->flags
& SEC_RELOC
)
752 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
753 hdr
[indx
].sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
756 if (sect
->flags
& SEC_HAS_CONTENTS
)
758 hdr
[indx
].sh_offset
= sect
->filepos
;
759 hdr
[indx
].sh_size
= sect
->_raw_size
;
761 if (sect
->flags
& SEC_ALLOC
)
763 hdr
[indx
].sh_flags
|= SHF_ALLOC
;
764 if (sect
->flags
& SEC_LOAD
)
766 /* do something with sh_type ? */
769 if (!(sect
->flags
& SEC_READONLY
))
770 hdr
[indx
].sh_flags
|= SHF_WRITE
;
772 if (sect
->flags
& SEC_CODE
)
773 hdr
[indx
].sh_flags
|= SHF_EXECINSTR
;
778 /* Create a new bfd section from an ELF program header.
780 Since program segments have no names, we generate a synthetic name
781 of the form segment<NUM>, where NUM is generally the index in the
782 program header table. For segments that are split (see below) we
783 generate the names segment<NUM>a and segment<NUM>b.
785 Note that some program segments may have a file size that is different than
786 (less than) the memory size. All this means is that at execution the
787 system must allocate the amount of memory specified by the memory size,
788 but only initialize it with the first "file size" bytes read from the
789 file. This would occur for example, with program segments consisting
790 of combined data+bss.
792 To handle the above situation, this routine generates TWO bfd sections
793 for the single program segment. The first has the length specified by
794 the file size of the segment, and the second has the length specified
795 by the difference between the two sizes. In effect, the segment is split
796 into it's initialized and uninitialized parts.
801 DEFUN (bfd_section_from_phdr
, (abfd
, hdr
, index
),
803 Elf_Internal_Phdr
* hdr AND
811 split
= ((hdr
->p_memsz
> 0) &&
812 (hdr
->p_filesz
> 0) &&
813 (hdr
->p_memsz
> hdr
->p_filesz
));
814 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
815 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
816 strcpy (name
, namebuf
);
817 newsect
= bfd_make_section (abfd
, name
);
818 newsect
->vma
= hdr
->p_vaddr
;
819 newsect
->_raw_size
= hdr
->p_filesz
;
820 newsect
->filepos
= hdr
->p_offset
;
821 newsect
->flags
|= SEC_HAS_CONTENTS
;
822 if (hdr
->p_type
== PT_LOAD
)
824 newsect
->flags
|= SEC_ALLOC
;
825 newsect
->flags
|= SEC_LOAD
;
826 if (hdr
->p_flags
& PF_X
)
828 /* FIXME: all we known is that it has execute PERMISSION,
830 newsect
->flags
|= SEC_CODE
;
833 if (!(hdr
->p_flags
& PF_W
))
835 newsect
->flags
|= SEC_READONLY
;
840 sprintf (namebuf
, "segment%db", index
);
841 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
842 strcpy (name
, namebuf
);
843 newsect
= bfd_make_section (abfd
, name
);
844 newsect
->vma
= hdr
->p_vaddr
+ hdr
->p_filesz
;
845 newsect
->_raw_size
= hdr
->p_memsz
- hdr
->p_filesz
;
846 if (hdr
->p_type
== PT_LOAD
)
848 newsect
->flags
|= SEC_ALLOC
;
849 if (hdr
->p_flags
& PF_X
)
850 newsect
->flags
|= SEC_CODE
;
852 if (!(hdr
->p_flags
& PF_W
))
853 newsect
->flags
|= SEC_READONLY
;
862 DEFUN (bfd_prstatus
, (abfd
, descdata
, descsz
, filepos
),
869 prstatus_t
*status
= (prstatus_t
*) 0;
871 if (descsz
== sizeof (prstatus_t
))
873 newsect
= bfd_make_section (abfd
, ".reg");
874 newsect
->_raw_size
= sizeof (status
->pr_reg
);
875 newsect
->filepos
= filepos
+ (long) &status
->pr_reg
;
876 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
877 newsect
->alignment_power
= 2;
878 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
880 memcpy (core_prstatus (abfd
), descdata
, descsz
);
885 /* Stash a copy of the prpsinfo structure away for future use. */
888 DEFUN (bfd_prpsinfo
, (abfd
, descdata
, descsz
, filepos
),
896 if (descsz
== sizeof (prpsinfo_t
))
898 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
900 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
906 DEFUN (bfd_fpregset
, (abfd
, descdata
, descsz
, filepos
),
914 newsect
= bfd_make_section (abfd
, ".reg2");
915 newsect
->_raw_size
= descsz
;
916 newsect
->filepos
= filepos
;
917 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
918 newsect
->alignment_power
= 2;
921 #endif /* HAVE_PROCFS */
923 /* Return a pointer to the args (including the command name) that were
924 seen by the program that generated the core dump. Note that for
925 some reason, a spurious space is tacked onto the end of the args
926 in some (at least one anyway) implementations, so strip it off if
930 DEFUN (elf_core_file_failing_command
, (abfd
),
934 if (core_prpsinfo (abfd
))
936 prpsinfo_t
*p
= core_prpsinfo (abfd
);
937 char *scan
= p
->pr_psargs
;
942 if ((scan
> p
->pr_psargs
) && (*scan
== ' '))
952 /* Return the number of the signal that caused the core dump. Presumably,
953 since we have a core file, we got a signal of some kind, so don't bother
954 checking the other process status fields, just return the signal number.
958 DEFUN (elf_core_file_failing_signal
, (abfd
),
962 if (core_prstatus (abfd
))
964 return ((prstatus_t
*) (core_prstatus (abfd
)))->pr_cursig
;
970 /* Check to see if the core file could reasonably be expected to have
971 come for the current executable file. Note that by default we return
972 true unless we find something that indicates that there might be a
977 DEFUN (elf_core_file_matches_executable_p
, (core_bfd
, exec_bfd
),
986 /* First, xvecs must match since both are ELF files for the same target. */
988 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
990 bfd_error
= system_call_error
;
996 /* If no prpsinfo, just return true. Otherwise, grab the last component
997 of the exec'd pathname from the prpsinfo. */
999 if (core_prpsinfo (core_bfd
))
1001 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
))->pr_fname
);
1008 /* Find the last component of the executable pathname. */
1010 if ((execname
= strrchr (exec_bfd
->filename
, '/')) != NULL
)
1016 execname
= (char *) exec_bfd
->filename
;
1019 /* See if they match */
1021 return strcmp (execname
, corename
) ? false : true;
1027 #endif /* HAVE_PROCFS */
1030 /* ELF core files contain a segment of type PT_NOTE, that holds much of
1031 the information that would normally be available from the /proc interface
1032 for the process, at the time the process dumped core. Currently this
1033 includes copies of the prstatus, prpsinfo, and fpregset structures.
1035 Since these structures are potentially machine dependent in size and
1036 ordering, bfd provides two levels of support for them. The first level,
1037 available on all machines since it does not require that the host
1038 have /proc support or the relevant include files, is to create a bfd
1039 section for each of the prstatus, prpsinfo, and fpregset structures,
1040 without any interpretation of their contents. With just this support,
1041 the bfd client will have to interpret the structures itself. Even with
1042 /proc support, it might want these full structures for it's own reasons.
1044 In the second level of support, where HAVE_PROCFS is defined, bfd will
1045 pick apart the structures to gather some additional information that
1046 clients may want, such as the general register set, the name of the
1047 exec'ed file and its arguments, the signal (if any) that caused the
1053 DEFUN (elf_corefile_note
, (abfd
, hdr
),
1055 Elf_Internal_Phdr
* hdr
)
1057 Elf_External_Note
*x_note_p
; /* Elf note, external form */
1058 Elf_Internal_Note i_note
; /* Elf note, internal form */
1059 char *buf
= NULL
; /* Entire note segment contents */
1060 char *namedata
; /* Name portion of the note */
1061 char *descdata
; /* Descriptor portion of the note */
1062 char *sectname
; /* Name to use for new section */
1063 long filepos
; /* File offset to descriptor data */
1066 if (hdr
->p_filesz
> 0
1067 && (buf
= (char *) bfd_xmalloc (hdr
->p_filesz
)) != NULL
1068 && bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != -1
1069 && bfd_read ((PTR
) buf
, hdr
->p_filesz
, 1, abfd
) == hdr
->p_filesz
)
1071 x_note_p
= (Elf_External_Note
*) buf
;
1072 while ((char *) x_note_p
< (buf
+ hdr
->p_filesz
))
1074 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->namesz
);
1075 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->descsz
);
1076 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
->type
);
1077 namedata
= x_note_p
->name
;
1078 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
1079 filepos
= hdr
->p_offset
+ (descdata
- buf
);
1080 switch (i_note
.type
)
1083 /* process descdata as prstatus info */
1084 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
1085 sectname
= ".prstatus";
1088 /* process descdata as fpregset info */
1089 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
1090 sectname
= ".fpregset";
1093 /* process descdata as prpsinfo */
1094 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
1095 sectname
= ".prpsinfo";
1098 /* Unknown descriptor, just ignore it. */
1102 if (sectname
!= NULL
)
1104 newsect
= bfd_make_section (abfd
, sectname
);
1105 newsect
->_raw_size
= i_note
.descsz
;
1106 newsect
->filepos
= filepos
;
1107 newsect
->flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
1108 newsect
->alignment_power
= 2;
1110 x_note_p
= (Elf_External_Note
*)
1111 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
1123 /* Read a specified number of bytes at a specified offset in an ELF
1124 file, into a newly allocated buffer, and return a pointer to the
1128 DEFUN (elf_read
, (abfd
, offset
, size
),
1135 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
1137 bfd_error
= no_memory
;
1140 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
1142 bfd_error
= system_call_error
;
1145 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
1147 bfd_error
= system_call_error
;
1153 /* Begin processing a given object.
1155 First we validate the file by reading in the ELF header and checking
1156 the magic number. */
1158 static INLINE boolean
1159 DEFUN (elf_file_p
, (x_ehdrp
), Elf_External_Ehdr
* x_ehdrp
)
1161 return ((x_ehdrp
->e_ident
[EI_MAG0
] == ELFMAG0
)
1162 && (x_ehdrp
->e_ident
[EI_MAG1
] == ELFMAG1
)
1163 && (x_ehdrp
->e_ident
[EI_MAG2
] == ELFMAG2
)
1164 && (x_ehdrp
->e_ident
[EI_MAG3
] == ELFMAG3
));
1168 DEFUN (elf_object_p
, (abfd
), bfd
* abfd
)
1170 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1171 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1172 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
1173 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
1175 char *shstrtab
; /* Internal copy of section header stringtab */
1176 struct elf_backend_data
*ebd
; /* Use to get ELF_ARCH stored in xvec */
1178 /* Read in the ELF header in external format. */
1180 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
1182 bfd_error
= system_call_error
;
1186 /* Now check to see if we have a valid ELF file, and one that BFD can
1187 make use of. The magic number must match, the address size ('class')
1188 and byte-swapping must match our XVEC entry, and it must have a
1189 section header table (FIXME: See comments re sections at top of this
1192 if (elf_file_p (&x_ehdr
) == false)
1195 bfd_error
= wrong_format
;
1199 if (x_ehdr
.e_ident
[EI_VERSION
] != EV_CURRENT
)
1203 unsigned int class = 0x12345;
1210 if (x_ehdr
.e_ident
[EI_CLASS
] != class)
1214 /* Switch xvec to match the specified byte order. */
1215 switch (x_ehdr
.e_ident
[EI_DATA
])
1217 case ELFDATA2MSB
: /* Big-endian */
1218 if (!abfd
->xvec
->header_byteorder_big_p
)
1221 case ELFDATA2LSB
: /* Little-endian */
1222 if (abfd
->xvec
->header_byteorder_big_p
)
1225 case ELFDATANONE
: /* No data encoding specified */
1226 default: /* Unknown data encoding specified */
1230 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
1231 the tdata pointer in the bfd. */
1233 if (NULL
== (elf_tdata (abfd
) = (struct elf_obj_tdata
*)
1234 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
))))
1236 bfd_error
= no_memory
;
1240 /* FIXME: Any `wrong' exits below here will leak memory (tdata). */
1242 /* Now that we know the byte order, swap in the rest of the header */
1243 i_ehdrp
= elf_elfheader (abfd
);
1244 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
1246 /* If there is no section header table, we're hosed. */
1247 if (i_ehdrp
->e_shoff
== 0)
1250 if (i_ehdrp
->e_type
== ET_EXEC
|| i_ehdrp
->e_type
== ET_DYN
)
1251 abfd
->flags
|= EXEC_P
;
1253 /* Retrieve the architecture information from the xvec and verify
1254 that it matches the machine info stored in the ELF header.
1255 This allows us to resolve ambiguous formats that might not
1256 otherwise be distinguishable. */
1258 ebd
= get_elf_backend_data (abfd
);
1259 switch (i_ehdrp
->e_machine
)
1264 /* Arguably EM_M32 should be bfd_arch_obscure, but then we would
1265 need both an elf32-obscure target and an elf32-unknown target.
1266 The distinction is probably not worth worrying about. */
1267 if (ebd
->arch
!= bfd_arch_unknown
)
1269 bfd_default_set_arch_mach (abfd
, bfd_arch_unknown
, 0);
1272 if (ebd
->arch
!= bfd_arch_sparc
)
1274 bfd_default_set_arch_mach (abfd
, bfd_arch_sparc
, 0);
1277 if (ebd
->arch
!= bfd_arch_i386
)
1279 bfd_default_set_arch_mach (abfd
, bfd_arch_i386
, 0);
1282 if (ebd
->arch
!= bfd_arch_m68k
)
1284 bfd_default_set_arch_mach (abfd
, bfd_arch_m68k
, 0);
1287 if (ebd
->arch
!= bfd_arch_m88k
)
1289 bfd_default_set_arch_mach (abfd
, bfd_arch_m88k
, 0);
1292 if (ebd
->arch
!= bfd_arch_i860
)
1294 bfd_default_set_arch_mach (abfd
, bfd_arch_i860
, 0);
1297 if (ebd
->arch
!= bfd_arch_mips
)
1299 bfd_default_set_arch_mach (abfd
, bfd_arch_mips
, 0);
1302 if (ebd
->arch
!= bfd_arch_hppa
)
1304 bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 0);
1308 /* Allocate space for a copy of the section header table in
1309 internal form, seek to the section header table in the file,
1310 read it in, and convert it to internal form. As a simple sanity
1311 check, verify that the what BFD thinks is the size of each section
1312 header table entry actually matches the size recorded in the file. */
1314 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
1316 i_shdrp
= (Elf_Internal_Shdr
*)
1317 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
);
1320 bfd_error
= no_memory
;
1323 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) == -1)
1325 bfd_error
= system_call_error
;
1328 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1330 if (bfd_read ((PTR
) & x_shdr
, sizeof x_shdr
, 1, abfd
)
1333 bfd_error
= system_call_error
;
1336 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
1339 elf_elfsections (abfd
) = i_shdrp
;
1341 /* Read in the string table containing the names of the sections. We
1342 will need the base pointer to this table later. */
1343 /* We read this inline now, so that we don't have to go through
1344 bfd_section_from_shdr with it (since this particular strtab is
1345 used to find all of the ELF section names.) */
1347 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
1351 /* Once all of the section headers have been read and converted, we
1352 can start processing them. Note that the first section header is
1353 a dummy placeholder entry, so we ignore it.
1355 We also watch for the symbol table section and remember the file
1356 offset and section size for both the symbol table section and the
1357 associated string table section. */
1359 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1361 bfd_section_from_shdr (abfd
, shindex
);
1364 /* Remember the entry point specified in the ELF file header. */
1366 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
1372 Takes a bfd and a symbol, returns a pointer to the elf specific area
1373 of the symbol if there is one.
1375 static INLINE elf_symbol_type
*
1376 DEFUN (elf_symbol_from
, (ignore_abfd
, symbol
),
1377 bfd
* ignore_abfd AND
1380 if (symbol
->the_bfd
->xvec
->flavour
!= bfd_target_elf_flavour
)
1383 if (symbol
->the_bfd
->tdata
.elf_obj_data
== (struct elf_obj_tdata
*) NULL
)
1386 return (elf_symbol_type
*) symbol
;
1389 /* Core files are simply standard ELF formatted files that partition
1390 the file using the execution view of the file (program header table)
1391 rather than the linking view. In fact, there is no section header
1392 table in a core file.
1394 The process status information (including the contents of the general
1395 register set) and the floating point register set are stored in a
1396 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
1397 that allow standard bfd access to the general registers (.reg) and the
1398 floating point registers (.reg2).
1403 DEFUN (elf_core_file_p
, (abfd
), bfd
* abfd
)
1405 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1406 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1407 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
1408 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
1409 unsigned int phindex
;
1411 /* Read in the ELF header in external format. */
1413 if (bfd_read ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
1415 bfd_error
= system_call_error
;
1419 /* Now check to see if we have a valid ELF file, and one that BFD can
1420 make use of. The magic number must match, the address size ('class')
1421 and byte-swapping must match our XVEC entry, and it must have a
1422 program header table (FIXME: See comments re segments at top of this
1425 if (elf_file_p (&x_ehdr
) == false)
1428 bfd_error
= wrong_format
;
1432 /* FIXME, Check EI_VERSION here ! */
1434 switch (x_ehdr
.e_ident
[EI_CLASS
])
1436 case ELFCLASSNONE
: /* address size not specified */
1437 goto wrong
; /* No support if can't tell address size */
1438 case ELFCLASS32
: /* 32-bit addresses */
1440 case ELFCLASS64
: /* 64-bit addresses */
1441 goto wrong
; /* FIXME: 64 bits not yet supported */
1443 goto wrong
; /* No support if unknown address class */
1446 /* Switch xvec to match the specified byte order. */
1447 switch (x_ehdr
.e_ident
[EI_DATA
])
1449 case ELFDATA2MSB
: /* Big-endian */
1450 if (abfd
->xvec
->byteorder_big_p
== false)
1453 case ELFDATA2LSB
: /* Little-endian */
1454 if (abfd
->xvec
->byteorder_big_p
== true)
1457 case ELFDATANONE
: /* No data encoding specified */
1458 default: /* Unknown data encoding specified */
1462 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
1463 the tdata pointer in the bfd. */
1466 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
1467 if (elf_tdata (abfd
) == NULL
)
1469 bfd_error
= no_memory
;
1473 /* FIXME, `wrong' returns from this point onward, leak memory. */
1475 /* Now that we know the byte order, swap in the rest of the header */
1476 i_ehdrp
= elf_elfheader (abfd
);
1477 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
1479 /* If there is no program header, or the type is not a core file, then
1481 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
1484 /* Allocate space for a copy of the program header table in
1485 internal form, seek to the program header table in the file,
1486 read it in, and convert it to internal form. As a simple sanity
1487 check, verify that the what BFD thinks is the size of each program
1488 header table entry actually matches the size recorded in the file. */
1490 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
1492 i_phdrp
= (Elf_Internal_Phdr
*)
1493 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
1496 bfd_error
= no_memory
;
1499 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
1501 bfd_error
= system_call_error
;
1504 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
1506 if (bfd_read ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
)
1509 bfd_error
= system_call_error
;
1512 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
1515 /* Once all of the program headers have been read and converted, we
1516 can start processing them. */
1518 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
1520 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
1521 if ((i_phdrp
+ phindex
)->p_type
== PT_NOTE
)
1523 elf_corefile_note (abfd
, i_phdrp
+ phindex
);
1527 /* Remember the entry point specified in the ELF file header. */
1529 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
1535 DEFUN (elf_mkobject
, (abfd
), bfd
* abfd
)
1537 /* this just does initialization */
1538 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
1539 elf_tdata (abfd
) = (struct elf_obj_tdata
*)
1540 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
1541 if (elf_tdata (abfd
) == 0)
1543 bfd_error
= no_memory
;
1546 /* since everything is done at close time, do we need any
1553 Create ELF output from BFD sections.
1555 Essentially, just create the section header and forget about the program
1561 elf_idx_of_sym (abfd
, sym
)
1566 for (i
= 0; i
< abfd
->symcount
; i
++)
1568 if (sym
== (asymbol
*) abfd
->outsymbols
[i
])
1571 BFD_ASSERT ((strcmp (sym
->name
, abfd
->outsymbols
[i
]->name
) == 0)
1572 || (strlen (sym
->name
) == 0));
1580 DEFUN (elf_make_sections
, (abfd
, asect
, obj
),
1582 asection
* asect AND
1585 elf_sect_thunk
*thunk
= (elf_sect_thunk
*) obj
;
1586 /* most of what is in bfd_shdr_from_section goes in here... */
1587 /* and all of these sections generate at *least* one ELF section. */
1591 /* check if we're making a PROGBITS section... */
1592 /* if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD)) */
1593 /* this was too strict... what *do* we want to check here? */
1596 Elf_Internal_Shdr
*this_hdr
;
1597 this_section
= elf_section_from_bfd_section (abfd
, asect
);
1598 this_hdr
= &thunk
->i_shdrp
[this_section
];
1600 this_hdr
->sh_addr
= asect
->vma
;
1601 this_hdr
->sh_size
= asect
->_raw_size
;
1602 /* contents already set by elf_set_section_contents */
1604 if (asect
->flags
& SEC_RELOC
)
1606 /* emit a reloc section, and thus strtab and symtab... */
1607 Elf_Internal_Shdr
*rela_hdr
;
1608 Elf_Internal_Shdr
*symtab_hdr
;
1609 Elf_External_Rela
*outbound_relocas
;
1610 Elf_External_Rel
*outbound_relocs
;
1612 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1614 symtab_hdr
= &thunk
->i_shdrp
[thunk
->symtab_section
];
1616 if (thunk
->symtab_section
== this_section
+ 1)
1617 rela_section
= thunk
->symtab_section
+ 2; /* symtab + symstrtab */
1619 rela_section
= this_section
+ 1;
1620 rela_hdr
= &thunk
->i_shdrp
[rela_section
];
1621 rela_hdr
->sh_link
= thunk
->symtab_section
;
1622 rela_hdr
->sh_info
= this_section
;
1624 /* orelocation has the data, reloc_count has the count... */
1627 rela_hdr
->sh_type
= SHT_RELA
;
1628 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1629 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* asect
->reloc_count
;
1630 outbound_relocas
= (Elf_External_Rela
*) bfd_alloc (abfd
, rela_hdr
->sh_size
);
1632 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
1634 Elf_Internal_Rela dst_rela
;
1635 Elf_External_Rela
*src_rela
;
1638 ptr
= asect
->orelocation
[idx
];
1639 src_rela
= outbound_relocas
+ idx
;
1640 if (!(abfd
->flags
& EXEC_P
))
1641 dst_rela
.r_offset
= ptr
->address
- asect
->vma
;
1643 dst_rela
.r_offset
= ptr
->address
;
1646 = ELF32_R_INFO (elf_symbol_from_bfd_symbol (abfd
, ptr
->sym_ptr_ptr
),
1649 dst_rela
.r_addend
= ptr
->addend
;
1650 elf_swap_reloca_out (abfd
, &dst_rela
, src_rela
);
1653 rela_hdr
->contents
= (void *) outbound_relocas
;
1656 /* REL relocations */
1658 rela_hdr
->sh_type
= SHT_REL
;
1659 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rel
);
1660 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* asect
->reloc_count
;
1661 outbound_relocs
= (Elf_External_Rel
*)
1662 bfd_alloc (abfd
, rela_hdr
->sh_size
);
1664 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
1666 Elf_Internal_Rel dst_rel
;
1667 Elf_External_Rel
*src_rel
;
1670 ptr
= asect
->orelocation
[idx
];
1671 src_rel
= outbound_relocs
+ idx
;
1672 if (!(abfd
->flags
& EXEC_P
))
1673 dst_rel
.r_offset
= ptr
->address
- asect
->vma
;
1675 dst_rel
.r_offset
= ptr
->address
;
1678 = ELF32_R_INFO (elf_symbol_from_bfd_symbol (abfd
, ptr
->sym_ptr_ptr
),
1681 elf_swap_reloc_out (abfd
, &dst_rel
, src_rel
);
1683 /* Update the addend -- FIXME add 64 bit support. */
1685 fprintf (stderr
, "Updating addend: 0x%.8lx = %d, this_section = %d\n",
1686 (long) ((unsigned char *) (elf_elfsections (abfd
)[this_section
].contents
)
1687 + dst_rel
.r_offset
), ptr
->addend
, this_section
);
1690 bfd_put_32 (abfd
, ptr
->addend
,
1691 (unsigned char *) (elf_elfsections (abfd
)[this_section
].contents
)
1692 + dst_rel
.r_offset
);
1694 rela_hdr
->contents
= (void *) outbound_relocs
;
1697 if (asect
->flags
& SEC_ALLOC
)
1699 this_hdr
->sh_flags
|= SHF_ALLOC
;
1700 if (asect
->flags
& SEC_LOAD
)
1702 /* @@ Do something with sh_type? */
1705 if (!(asect
->flags
& SEC_READONLY
))
1706 this_hdr
->sh_flags
|= SHF_WRITE
;
1708 if (asect
->flags
& SEC_CODE
)
1709 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1714 DEFUN (elf_fake_sections
, (abfd
, asect
, obj
),
1716 asection
* asect AND
1719 elf_sect_thunk
*thunk
= (elf_sect_thunk
*) obj
;
1720 /* most of what is in bfd_shdr_from_section goes in here... */
1721 /* and all of these sections generate at *least* one ELF section. */
1724 /* check if we're making a PROGBITS section... */
1725 /* if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD)) */
1726 /* this was too strict... what *do* we want to check here? */
1729 Elf_Internal_Shdr
*this_hdr
;
1730 this_section
= thunk
->i_ehdr
->e_shnum
++;
1731 this_hdr
= &thunk
->i_shdrp
[this_section
];
1733 bfd_add_to_strtab (abfd
, thunk
->shstrtab
, asect
->name
);
1734 /* we need to log the type *now* so that elf_section_from_bfd_section
1735 can find us... have to set rawdata too. */
1736 this_hdr
->rawdata
= (void *) asect
;
1737 this_hdr
->sh_addralign
= asect
->alignment_power
;
1738 if ((asect
->flags
& SEC_ALLOC
) && (asect
->flags
& SEC_LOAD
))
1739 this_hdr
->sh_type
= SHT_PROGBITS
;
1740 /* @@ Select conditions correctly! */
1741 else if (!strcmp (asect
->name
, ".bss"))
1742 this_hdr
->sh_type
= SHT_NOBITS
;
1744 /* what *do* we put here? */
1745 this_hdr
->sh_type
= SHT_PROGBITS
;
1749 /* Emit a strtab and symtab, and possibly a reloc section. */
1750 Elf_Internal_Shdr
*rela_hdr
;
1751 Elf_Internal_Shdr
*symtab_hdr
;
1752 Elf_Internal_Shdr
*symstrtab_hdr
;
1754 int symstrtab_section
;
1756 /* Note that only one symtab is used, so just remember it
1758 if (!thunk
->symtab_section
)
1760 thunk
->symtab_section
= thunk
->i_ehdr
->e_shnum
++;
1761 symtab_hdr
= &thunk
->i_shdrp
[thunk
->symtab_section
];
1762 symtab_hdr
->sh_name
=
1763 bfd_add_to_strtab (abfd
, thunk
->shstrtab
, ".symtab");
1764 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1765 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1767 symstrtab_section
= thunk
->i_ehdr
->e_shnum
++;
1768 BFD_ASSERT (symstrtab_section
== thunk
->symtab_section
+ 1);
1769 symstrtab_hdr
= &thunk
->i_shdrp
[symstrtab_section
];
1770 symtab_hdr
->sh_link
= symstrtab_section
;
1771 symstrtab_hdr
->sh_name
=
1772 bfd_add_to_strtab (abfd
, thunk
->shstrtab
, ".strtab");
1773 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
1775 symtab_hdr
->contents
= 0;
1776 symstrtab_hdr
->contents
= 0;
1777 symstrtab_hdr
->sh_size
= 0;
1780 symtab_hdr
= &thunk
->i_shdrp
[thunk
->symtab_section
];
1782 if (asect
->flags
& SEC_RELOC
)
1784 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
1786 rela_section
= thunk
->i_ehdr
->e_shnum
++;
1787 rela_hdr
= &thunk
->i_shdrp
[rela_section
];
1789 bfd_add_2_to_strtab (abfd
, thunk
->shstrtab
,
1790 use_rela_p
? ".rela" : ".rel",
1792 rela_hdr
->sh_type
= use_rela_p
? SHT_RELA
: SHT_REL
;
1793 rela_hdr
->sh_link
= thunk
->symtab_section
;
1794 rela_hdr
->sh_info
= this_section
;
1795 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1798 if (asect
->flags
& SEC_ALLOC
)
1800 this_hdr
->sh_flags
|= SHF_ALLOC
;
1801 if (asect
->flags
& SEC_LOAD
)
1803 /* @@ Do something with sh_type? */
1806 if (!(asect
->flags
& SEC_READONLY
))
1807 this_hdr
->sh_flags
|= SHF_WRITE
;
1808 if (asect
->flags
& SEC_CODE
)
1809 this_hdr
->sh_flags
|= SHF_EXECINSTR
;
1815 xxxINTERNAL_FUNCTION
1819 struct elf_internal_shdr *bfd_elf_locate_sh (bfd *abfd,
1820 struct strtab *strtab,
1821 struct elf_internal_shdr *shdrp,
1825 Helper function to locate an ELF section header given the
1826 name of a BFD section.
1829 struct elf32_internal_shdr
*
1830 DEFUN (bfd_elf_locate_sh
, (abfd
, strtab
, shdrp
, name
),
1832 struct strtab
*strtab AND
1833 struct elf32_internal_shdr
*shdrp AND
1836 Elf_Internal_Shdr
*gotit
= NULL
;
1839 if (shdrp
!= NULL
&& strtab
!= NULL
)
1841 max
= elf_elfheader (abfd
)->e_shnum
;
1842 for (i
= 1; i
< max
; i
++)
1844 if (!strcmp (strtab
->tab
+ shdrp
[i
].sh_name
, name
))
1853 /* Map symbol from it's internal number to the external number, moving
1854 all local symbols to be at the head of the list. */
1857 DEFUN (elf_map_symbols
, (abfd
), bfd
* abfd
)
1859 int symcount
= bfd_get_symcount (abfd
);
1860 asymbol
**syms
= bfd_get_outsymbols (abfd
);
1863 int num_globals
= 0;
1864 int num_locals2
= 0;
1865 int num_globals2
= 0;
1866 int num_sections
= 0;
1872 fprintf (stderr
, "elf_map_symbols\n");
1876 /* Add local symbols for each allocated section
1877 FIXME -- we should only put out symbols for sections that
1878 are actually relocated against. */
1879 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1881 if (asect
->flags
& (SEC_LOAD
| SEC_DATA
| SEC_CODE
))
1888 syms
= (asymbol
**) bfd_realloc (abfd
, syms
,
1889 ((symcount
+ num_sections
+ 1)
1890 * sizeof (asymbol
*)));
1892 syms
= (asymbol
**) bfd_alloc (abfd
,
1893 (num_sections
+ 1) * sizeof (asymbol
*));
1895 for (asect
= abfd
->sections
; asect
; asect
= asect
->next
)
1897 if (asect
->flags
& (SEC_LOAD
| SEC_DATA
| SEC_CODE
))
1899 asymbol
*sym
= syms
[symcount
++] = bfd_make_empty_symbol (abfd
);
1900 sym
->the_bfd
= abfd
;
1901 sym
->name
= asect
->name
;
1902 sym
->value
= asect
->vma
;
1903 sym
->flags
= BSF_SECTION_SYM
;
1904 sym
->section
= asect
;
1908 syms
[symcount
] = (asymbol
*) 0;
1909 bfd_set_symtab (abfd
, syms
, symcount
);
1912 elf_symtab_map (abfd
) = symtab_map
1913 = (int *) bfd_alloc (abfd
, symcount
* sizeof (int *));
1915 /* Identify and classify all of the symbols. */
1916 for (idx
= 0; idx
< symcount
; idx
++)
1918 flags
= syms
[idx
]->flags
;
1919 if (flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1925 /* Now provide mapping information. Add +1 for skipping over the
1927 for (idx
= 0; idx
< symcount
; idx
++)
1929 flags
= syms
[idx
]->flags
;
1930 if (flags
& (BSF_LOCAL
| BSF_SECTION_SYM
| BSF_FILE
))
1931 symtab_map
[idx
] = 1 + num_locals2
++;
1933 symtab_map
[idx
] = 1 + num_locals
+ num_globals2
++;
1936 elf_num_locals (abfd
) = num_locals
;
1937 elf_num_globals (abfd
) = num_globals
;
1942 DEFUN (elf_compute_section_file_positions
, (abfd
), bfd
* abfd
)
1944 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1945 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
1946 struct strtab
*shstrtab
;
1947 int count
, maxsections
;
1950 if (!elf_shstrtab (abfd
))
1952 i_ehdrp
= elf_elfheader (abfd
); /* build new header in tdata memory */
1953 shstrtab
= bfd_new_strtab (abfd
);
1955 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
1956 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
1957 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
1958 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
1960 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS32
; /* FIXME: find out from bfd */
1961 i_ehdrp
->e_ident
[EI_DATA
] =
1962 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
1963 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1965 for (count
= EI_PAD
; count
< EI_NIDENT
; count
++)
1966 i_ehdrp
->e_ident
[count
] = 0;
1968 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
) ? ET_EXEC
: ET_REL
;
1969 switch (bfd_get_arch (abfd
))
1971 case bfd_arch_unknown
:
1972 i_ehdrp
->e_machine
= EM_NONE
;
1974 case bfd_arch_sparc
:
1975 i_ehdrp
->e_machine
= EM_SPARC
;
1978 i_ehdrp
->e_machine
= EM_386
;
1981 i_ehdrp
->e_machine
= EM_68K
;
1984 i_ehdrp
->e_machine
= EM_88K
;
1987 i_ehdrp
->e_machine
= EM_860
;
1989 case bfd_arch_mips
: /* MIPS Rxxxx */
1990 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
1993 i_ehdrp
->e_machine
= EM_HPPA
;
1995 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
1997 i_ehdrp
->e_machine
= EM_NONE
;
1999 i_ehdrp
->e_version
= EV_CURRENT
;
2000 i_ehdrp
->e_ehsize
= sizeof (Elf_External_Ehdr
);
2002 /* no program header, for now. */
2003 i_ehdrp
->e_phoff
= 0;
2004 i_ehdrp
->e_phentsize
= 0;
2005 i_ehdrp
->e_phnum
= 0;
2007 /* each bfd section is section header entry */
2008 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
2009 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
2011 /* figure at most each section can have a rel, strtab, symtab */
2012 maxsections
= 4 * bfd_count_sections (abfd
) + 2;
2014 i_ehdrp
->e_shoff
= i_ehdrp
->e_ehsize
;
2016 /* and we'll just have to fix up the offsets later. */
2017 /* outbase += i_ehdr.e_shentsize * i_ehdr.e_shnum; */
2019 i_shdrp
= (Elf_Internal_Shdr
*)
2020 bfd_alloc (abfd
, sizeof (*i_shdrp
) * maxsections
);
2023 bfd_error
= no_memory
;
2026 for (count
= 0; count
< maxsections
; count
++)
2028 i_shdrp
[count
].rawdata
= 0;
2029 i_shdrp
[count
].contents
= 0;
2033 i_shdrp
[0].sh_name
= 0;
2034 i_shdrp
[0].sh_type
= SHT_NULL
;
2035 i_shdrp
[0].sh_flags
= 0;
2036 i_shdrp
[0].sh_addr
= 0;
2037 i_shdrp
[0].sh_offset
= 0;
2038 i_shdrp
[0].sh_size
= 0;
2039 i_shdrp
[0].sh_link
= SHN_UNDEF
;
2040 i_shdrp
[0].sh_info
= 0;
2041 i_shdrp
[0].sh_addralign
= 0;
2042 i_shdrp
[0].sh_entsize
= 0;
2044 i_ehdrp
->e_shnum
= 1;
2046 elf_elfsections (abfd
) = i_shdrp
;
2047 elf_shstrtab (abfd
) = shstrtab
;
2049 est
.i_ehdr
= elf_elfheader (abfd
);
2050 est
.i_shdrp
= elf_elfsections (abfd
);
2051 est
.shstrtab
= elf_shstrtab (abfd
);
2052 est
.symtab_section
= 0; /* elf_fake_sections fills it in */
2054 elf_map_symbols (abfd
);
2055 bfd_map_over_sections (abfd
, elf_fake_sections
, &est
);
2058 asection
*psecp
= (asection
*) 0;
2060 Elf_Internal_Shdr
*shp
;
2062 for (idx
= 0, secp
= abfd
->sections
; secp
; idx
++, secp
= secp
->next
)
2064 if (psecp
== (asection
*) 0)
2066 secp
->filepos
= est
.i_ehdr
->e_shoff
+ (est
.i_ehdr
->e_shnum
+ 1) * sizeof (Elf_External_Shdr
);
2070 secp
->filepos
= psecp
->filepos
+ psecp
->_cooked_size
;
2072 shp
= bfd_elf_locate_sh (abfd
, est
.shstrtab
, est
.i_shdrp
, secp
->name
);
2074 shp
->sh_offset
= secp
->filepos
;
2078 elf_onesymtab (abfd
) = est
.symtab_section
;
2083 DEFUN (elf_write_phdrs
, (abfd
, i_ehdrp
, i_phdrp
, phdr_cnt
),
2085 Elf_Internal_Ehdr
* i_ehdrp AND
2086 Elf_Internal_Phdr
* i_phdrp AND
2087 Elf32_Half phdr_cnt
)
2089 /* first program header entry goes after the file header */
2090 int outbase
= i_ehdrp
->e_ehsize
;
2092 Elf_External_Phdr x_phdr
;
2094 for (i
= 0; i
< phdr_cnt
; i
++)
2096 elf_swap_phdr_out (abfd
, i_phdrp
+ i
, &x_phdr
);
2097 bfd_seek (abfd
, outbase
, SEEK_SET
);
2098 bfd_write ((PTR
) & x_phdr
, sizeof (x_phdr
), 1, abfd
);
2099 outbase
+= sizeof (x_phdr
);
2105 static Elf_Internal_Phdr
*
2106 DEFUN (elf_build_phdrs
, (abfd
, i_ehdrp
, i_shdrp
, phdr_cnt
),
2108 Elf_Internal_Ehdr
* i_ehdrp AND
2109 Elf_Internal_Shdr
* i_shdrp AND
2110 Elf32_Half
* phdr_cnt
)
2112 Elf_Internal_Phdr
*phdr_buf
;
2115 1. The program header table is *not* loaded as part
2116 of the memory image of the program. If this
2117 changes later, the PT_PHDR entry must come first.
2118 2. there is currently no support for program header
2119 entries of type PT_PHDR, PT_DYNAMIC, PT_INTERP,
2122 /* A. Figure out how many program header table entries are needed
2123 1. PT_LOAD for the text segment
2124 2. PT_LOAD for the data segment
2125 Then, reserve space for one more pointer. This will be NULL
2126 to indicate the end of the program header table. */
2128 #ifdef PHDRS_INCLUDED
2131 /* XXX right now, execve() expects exactly 3 PT entries on HPPA-OSF. */
2135 phdr_buf
= (Elf_Internal_Phdr
*) bfd_xmalloc (((*phdr_cnt
) + 1)
2137 sizeof (Elf_Internal_Phdr
));
2140 #ifdef PHDRS_INCLUDED
2141 /* B. Fill in the PT_PHDR entry. */
2146 /* C. Fill in the PT_LOAD entry for the text segment. */
2148 phdr_buf
[idx
].p_type
= PT_LOAD
;
2150 /* get virtual/physical address from .text section */
2151 phdr_buf
[idx
].p_vaddr
= bfd_get_section_by_name (abfd
, ".text")->vma
;
2152 phdr_buf
[idx
].p_paddr
= 0; /* XXX */
2154 /* Ultimately, we would like the size of the .text load
2155 segment to be the sum of the following sections:
2156 the program header table itself
2167 But, right now, it will be the sum of the following sections:
2172 static char *CONST ld_sect_names
[] =
2173 {".text", ".rodata", NULL
};
2177 for (i
= 0; ld_sect_names
[i
]; i
++)
2179 asection
*asect
= bfd_get_section_by_name (abfd
,
2183 ld_size
+= bfd_section_size (abfd
, asect
);
2185 phdr_buf
[idx
].p_filesz
= ld_size
;
2186 /* XXX: need to fix this */
2187 phdr_buf
[idx
].p_memsz
= ld_size
;
2189 phdr_buf
[idx
].p_flags
= PF_R
+ PF_X
;
2190 phdr_buf
[idx
].p_align
=
2191 bfd_get_section_by_name (abfd
, ".text")->alignment_power
;
2195 /* D. Fill in the PT_LOAD entry for the data segment. */
2197 phdr_buf
[idx
].p_type
= PT_LOAD
;
2199 /* get virtual/physical address from .data section */
2200 phdr_buf
[idx
].p_vaddr
= bfd_get_section_by_name (abfd
, ".data")->vma
;
2201 phdr_buf
[idx
].p_paddr
= 0; /* XXX */
2203 /* Ultimately, we would like the size of the data load segment
2204 to be the sum of the following sections:
2205 the PT_DYNAMIC program header table entry
2211 But, right now, it will be the sum of the following sections:
2215 static char *CONST ld_sect_names
[] =
2220 for (i
= 0; ld_sect_names
[i
]; i
++)
2222 asection
*asect
= bfd_get_section_by_name (abfd
,
2226 ld_size
+= bfd_section_size (abfd
, asect
);
2228 phdr_buf
[idx
].p_filesz
= ld_size
;
2229 /* XXX: need to fix this */
2230 phdr_buf
[idx
].p_memsz
= ld_size
;
2232 phdr_buf
[idx
].p_flags
= PF_R
+ PF_W
+ PF_X
;
2233 phdr_buf
[idx
].p_align
2234 = bfd_get_section_by_name (abfd
, ".data")->alignment_power
;
2238 /* E. Fill in the PT_LOAD entry for the bss segment. */
2240 phdr_buf
[idx
].p_type
= PT_LOAD
;
2242 /* get virtual/physical address from .data section */
2243 phdr_buf
[idx
].p_vaddr
= bfd_get_section_by_name (abfd
, ".bss")->vma
;
2244 phdr_buf
[idx
].p_paddr
= 0; /* XXX */
2247 static char *CONST ld_sect_names
[] =
2252 for (i
= 0; ld_sect_names
[i
]; i
++)
2254 asection
*asect
= bfd_get_section_by_name (abfd
,
2258 ld_size
+= bfd_section_size (abfd
, asect
);
2260 phdr_buf
[idx
].p_filesz
= 0;
2261 /* XXX: need to fix this */
2262 phdr_buf
[idx
].p_memsz
= ld_size
;
2264 phdr_buf
[idx
].p_flags
= PF_R
+ PF_W
+ PF_X
;
2265 phdr_buf
[idx
].p_align
2266 = bfd_get_section_by_name (abfd
, ".bss")->alignment_power
;
2270 /* F. Set up the "end of program header table" sentinel. */
2272 bzero ((char *) (phdr_buf
+ idx
), sizeof (Elf_Internal_Phdr
));
2275 BFD_ASSERT (idx
- 1 == *phdr_cnt
);
2281 DEFUN (elf_write_object_contents
, (abfd
), bfd
* abfd
)
2283 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
2284 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
2285 Elf_Internal_Phdr
*i_phdrp
= 0; /* Program header table, internal form */
2286 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
2287 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
2294 struct strtab
*shstrtab
;
2296 if (abfd
->output_has_begun
== false)
2298 elf_compute_section_file_positions (abfd
);
2299 abfd
->output_has_begun
= true;
2302 i_ehdrp
= elf_elfheader (abfd
);
2303 i_shdrp
= elf_elfsections (abfd
);
2304 shstrtab
= elf_shstrtab (abfd
);
2306 est
.i_ehdr
= i_ehdrp
;
2307 est
.i_shdrp
= i_shdrp
;
2308 est
.shstrtab
= shstrtab
;
2309 est
.symtab_section
= elf_onesymtab (abfd
); /* filled in by elf_fake */
2311 bfd_map_over_sections (abfd
, elf_make_sections
, &est
);
2313 /* Dump out the symtabs. */
2315 int symcount
= bfd_get_symcount (abfd
);
2316 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2317 struct strtab
*stt
= bfd_new_strtab (abfd
);
2318 Elf_Internal_Shdr
*symtab_hdr
;
2319 Elf_Internal_Shdr
*symstrtab_hdr
;
2320 int symstrtab_section
;
2321 Elf_External_Sym
*outbound_syms
;
2324 symtab_hdr
= &i_shdrp
[est
.symtab_section
];
2325 symtab_hdr
->sh_type
= SHT_SYMTAB
;
2326 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
2327 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* (symcount
+ 1);
2328 symtab_hdr
->sh_info
= elf_num_locals (abfd
) + 1;
2330 /* see assert in elf_fake_sections that supports this: */
2331 symstrtab_section
= est
.symtab_section
+ 1;
2332 symstrtab_hdr
= &i_shdrp
[symstrtab_section
];
2333 symtab_hdr
->sh_link
= symstrtab_section
;
2334 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2336 outbound_syms
= (Elf_External_Sym
*)
2337 bfd_alloc (abfd
, (1 + symcount
) * sizeof (Elf_External_Sym
));
2338 /* now generate the data (for "contents") */
2340 /* Fill in zeroth symbol and swap it out. */
2341 Elf_Internal_Sym sym
;
2347 sym
.st_shndx
= SHN_UNDEF
;
2348 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
2350 for (idx
= 0; idx
< symcount
; idx
++)
2352 Elf_Internal_Sym sym
;
2353 bfd_vma value
= syms
[idx
]->value
;
2355 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
2357 value
+= syms
[idx
]->section
->output_section
->vma
2358 + syms
[idx
]->section
->output_offset
;
2359 sym
.st_value
= value
;
2361 sym
.st_size
= (Elf32_Word
) (elf_symbol_from (abfd
, syms
[idx
]))->internal_elf_sym
.st_size
;
2363 if (syms
[idx
]->flags
& BSF_WEAK
)
2364 sym
.st_info
= ELF_ST_INFO (STB_WEAK
, STT_OBJECT
);
2365 else if (syms
[idx
]->flags
& BSF_LOCAL
)
2367 if (syms
[idx
]->flags
& BSF_FUNCTION
)
2368 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FUNC
);
2370 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_OBJECT
);
2372 else if (syms
[idx
]->flags
& BSF_GLOBAL
)
2374 if (syms
[idx
]->flags
& BSF_FUNCTION
)
2375 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_FUNC
);
2377 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2379 else if (syms
[idx
]->flags
& BSF_EXPORT
)
2381 if (syms
[idx
]->flags
& BSF_FUNCTION
)
2382 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_FUNC
);
2384 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2386 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
2387 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
2388 else if (syms
[idx
]->flags
& BSF_FILE
)
2389 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_FILE
);
2391 sym
.st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_OBJECT
);
2394 if (syms
[idx
]->section
)
2396 elf_section_from_bfd_section (abfd
,
2397 syms
[idx
]->section
->output_section
);
2399 sym
.st_shndx
= SHN_UNDEF
;
2401 elf_swap_symbol_out (abfd
, &sym
,
2402 outbound_syms
+ elf_symtab_map (abfd
)[idx
]);
2405 symtab_hdr
->contents
= (void *) outbound_syms
;
2406 symstrtab_hdr
->contents
= (void *) stt
->tab
;
2407 symstrtab_hdr
->sh_size
= stt
->length
;
2408 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
2411 /* put the strtab out too... */
2413 Elf_Internal_Shdr
*this_hdr
;
2416 this_section
= i_ehdrp
->e_shnum
++;
2417 i_ehdrp
->e_shstrndx
= this_section
;
2418 this_hdr
= &i_shdrp
[this_section
];
2419 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, shstrtab
, ".shstrtab");
2420 this_hdr
->sh_type
= SHT_STRTAB
;
2421 this_hdr
->sh_size
= shstrtab
->length
;
2422 this_hdr
->contents
= (void *) shstrtab
->tab
;
2425 outbase
= i_ehdrp
->e_ehsize
;
2427 /* if we're building an executable, we'll need a program header table */
2428 if (abfd
->flags
& EXEC_P
)
2430 i_ehdrp
->e_phentsize
= sizeof (Elf_External_Phdr
);
2432 /* elf_build_phdrs() returns a (NULL-terminated) array of
2433 Elf_Internal_Phdrs */
2434 i_phdrp
= elf_build_phdrs (abfd
, i_ehdrp
, i_shdrp
, &i_ehdrp
->e_phnum
);
2435 i_ehdrp
->e_phoff
= i_ehdrp
->e_ehsize
;
2436 i_ehdrp
->e_shoff
= i_ehdrp
->e_phoff
+ (i_ehdrp
->e_phentsize
2437 * i_ehdrp
->e_phnum
);
2440 /* swap the header before spitting it out... */
2441 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
2442 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
2443 bfd_write ((PTR
) & x_ehdr
, sizeof (x_ehdr
), 1, abfd
);
2446 outbase
+= i_ehdrp
->e_phentsize
* i_ehdrp
->e_phnum
;
2447 outbase
+= i_ehdrp
->e_shentsize
* i_ehdrp
->e_shnum
;
2449 /* find the next available location in the file
2450 (just beyond the sections that have already been written). */
2452 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2454 if (i_shdrp
[count
].sh_offset
&& outbase
< i_shdrp
[count
].sh_offset
)
2455 outbase
= i_shdrp
[count
].sh_offset
+ i_shdrp
[count
].sh_size
;
2458 /* now we fix up the offsets... */
2459 for (count
= 1; count
< i_ehdrp
->e_shnum
; count
++)
2461 if (i_shdrp
[count
].sh_offset
== 0)
2462 i_shdrp
[count
].sh_offset
= outbase
;
2463 outbase
+= i_shdrp
[count
].sh_size
;
2466 /* If we're building an executable, fixup the program header table
2469 @@ For now, assume that the entries are in a fixed order: text,
2472 if (abfd
->flags
& EXEC_P
)
2474 static char *CONST section_name
[] =
2475 {".text", ".data", ".bss"};
2477 for (count
= 0; count
< 3; count
++)
2479 asection
*asect
= bfd_get_section_by_name (abfd
, section_name
[count
]);
2480 int sh_idx
= elf_section_from_bfd_section (abfd
, asect
);
2482 i_phdrp
[count
].p_offset
= i_shdrp
[sh_idx
].sh_offset
;
2485 /* write out the program header table entries */
2486 elf_write_phdrs (abfd
, i_ehdrp
, i_phdrp
, i_ehdrp
->e_phnum
);
2489 /* at this point we've concocted all the ELF sections... */
2490 x_shdrp
= (Elf_External_Shdr
*)
2491 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
2494 bfd_error
= no_memory
;
2498 for (count
= 0, scnt
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2500 elf_swap_shdr_out (abfd
, i_shdrp
+ count
, x_shdrp
+ scnt
);
2503 bfd_write ((PTR
) x_shdrp
, sizeof (*x_shdrp
), i_ehdrp
->e_shnum
, abfd
);
2504 /* need to dump the string table too... */
2506 /* after writing the headers, we need to write the sections too... */
2507 nsect
= abfd
->sections
;
2508 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
2510 if (i_shdrp
[count
].contents
)
2512 bfd_seek (abfd
, i_shdrp
[count
].sh_offset
, SEEK_SET
);
2513 bfd_write (i_shdrp
[count
].contents
, i_shdrp
[count
].sh_size
, 1, abfd
);
2520 /* Given an index of a section, retrieve a pointer to it. Note
2521 that for our purposes, sections are indexed by {1, 2, ...} with
2522 0 being an illegal index. */
2524 /* In the original, each ELF section went into exactly one BFD
2525 section. This doesn't really make sense, so we need a real mapping.
2526 The mapping has to hide in the Elf_Internal_Shdr since asection
2527 doesn't have anything like a tdata field... */
2530 DEFUN (section_from_elf_index
, (abfd
, index
),
2534 /* @@ Is bfd_com_section really correct in all the places it could
2535 be returned from this routine? */
2537 if (index
== SHN_ABS
)
2538 return &bfd_com_section
;
2539 if (index
== SHN_COMMON
)
2540 return &bfd_com_section
;
2543 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
2544 Elf_Internal_Shdr
*hdr
= i_shdrp
+ index
;
2546 switch (hdr
->sh_type
)
2548 /* ELF sections that map to BFD sections */
2552 bfd_section_from_shdr (abfd
, index
);
2553 return (struct sec
*) hdr
->rawdata
;
2556 return (struct sec
*) &bfd_abs_section
;
2561 /* given a section, search the header to find them... */
2563 DEFUN (elf_section_from_bfd_section
, (abfd
, asect
),
2567 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
2569 Elf_Internal_Shdr
*hdr
;
2570 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
2572 if (asect
== &bfd_abs_section
)
2574 if (asect
== &bfd_com_section
)
2577 for (index
= 0; index
< maxindex
; index
++)
2579 hdr
= &i_shdrp
[index
];
2580 switch (hdr
->sh_type
)
2582 /* ELF sections that map to BFD sections */
2587 if (((struct sec
*) (hdr
->rawdata
)) == asect
)
2598 /* given a symbol, return the bfd index for that symbol. */
2600 DEFUN (elf_symbol_from_bfd_symbol
, (abfd
, asym_ptr_ptr
),
2602 struct symbol_cache_entry
**asym_ptr_ptr
)
2604 struct symbol_cache_entry
*asym_ptr
= *asym_ptr_ptr
;
2605 CONST
char *name
= asym_ptr
->name
;
2606 flagword flags
= asym_ptr
->flags
;
2608 int symcount
= bfd_get_symcount (abfd
);
2609 asymbol
**syms
= bfd_get_outsymbols (abfd
);
2611 /* FIXME -- there has to be a better way than linear search. */
2612 for (idx
= 0; idx
< symcount
; idx
++)
2614 if (syms
[idx
] == asym_ptr
|| (name
== syms
[idx
]->name
&& name
))
2618 BFD_ASSERT (idx
< symcount
);
2619 idx
= elf_symtab_map (abfd
)[idx
];
2622 fprintf (stderr
, "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags =",
2623 (long) asym_ptr
, asym_ptr
->name
, idx
);
2625 if (flags
== BSF_NO_FLAGS
)
2626 fprintf (stderr
, " none");
2628 if (flags
& BSF_LOCAL
)
2629 fprintf (stderr
, " local");
2631 if (flags
& BSF_GLOBAL
)
2632 fprintf (stderr
, " global");
2634 if (flags
& BSF_IMPORT
)
2635 fprintf (stderr
, " import");
2637 if (flags
& BSF_EXPORT
)
2638 fprintf (stderr
, " export");
2640 if (flags
& BSF_UNDEFINED_OBS
)
2641 fprintf (stderr
, " undefined_obs");
2643 if (flags
& BSF_FORT_COMM_OBS
)
2644 fprintf (stderr
, " fort_comm_obs");
2646 if (flags
& BSF_DEBUGGING
)
2647 fprintf (stderr
, " debugging");
2649 if (flags
& BSF_KEEP
)
2650 fprintf (stderr
, " keep");
2652 if (flags
& BSF_KEEP_G
)
2653 fprintf (stderr
, " keep_g");
2655 if (flags
& BSF_WEAK
)
2656 fprintf (stderr
, " weak");
2658 if (flags
& BSF_CTOR
)
2659 fprintf (stderr
, " ctor");
2661 if (flags
& BSF_SECTION_SYM
)
2662 fprintf (stderr
, " section_sym");
2664 if (flags
& BSF_OLD_COMMON
)
2665 fprintf (stderr
, " old_common");
2667 if (flags
& BSF_NOT_AT_END
)
2668 fprintf (stderr
, " not_at_end");
2670 if (flags
& BSF_CONSTRUCTOR
)
2671 fprintf (stderr
, " constructor");
2673 if (flags
& BSF_WARNING
)
2674 fprintf (stderr
, " warning");
2676 if (flags
& BSF_INDIRECT
)
2677 fprintf (stderr
, " indirect");
2679 if (flags
& BSF_FILE
)
2680 fprintf (stderr
, " file");
2682 if (flags
& BSF_FUNCTION
)
2683 fprintf (stderr
, " function");
2685 putc ('\n', stderr
);
2693 DEFUN (elf_slurp_symbol_table
, (abfd
, symptrs
),
2695 asymbol
** symptrs
) /* Buffer for generated bfd symbols */
2697 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
2698 Elf_Internal_Shdr
*hdr
= i_shdrp
+ elf_onesymtab (abfd
);
2699 int symcount
; /* Number of external ELF symbols */
2701 elf_symbol_type
*sym
; /* Pointer to current bfd symbol */
2702 elf_symbol_type
*symbase
; /* Buffer for generated bfd symbols */
2703 Elf_Internal_Sym i_sym
;
2704 Elf_External_Sym
*x_symp
;
2706 /* this is only valid because there is only one symtab... */
2707 /* FIXME: This is incorrect, there may also be a dynamic symbol
2708 table which is a subset of the full symbol table. We either need
2709 to be prepared to read both (and merge them) or ensure that we
2710 only read the full symbol table. Currently we only get called to
2711 read the full symbol table. -fnf */
2712 if (bfd_get_outsymbols (abfd
) != NULL
)
2717 /* Read each raw ELF symbol, converting from external ELF form to
2718 internal ELF form, and then using the information to create a
2719 canonical bfd symbol table entry.
2721 Note that we allocate the initial bfd canonical symbol buffer
2722 based on a one-to-one mapping of the ELF symbols to canonical
2723 symbols. We actually use all the ELF symbols, so there will be no
2724 space left over at the end. When we have all the symbols, we
2725 build the caller's pointer vector. */
2727 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
2729 bfd_error
= system_call_error
;
2733 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2734 symbase
= (elf_symbol_type
*) bfd_zalloc (abfd
, symcount
* sizeof (elf_symbol_type
));
2737 /* Temporarily allocate room for the raw ELF symbols. */
2738 x_symp
= (Elf_External_Sym
*) bfd_xmalloc (symcount
* sizeof (Elf_External_Sym
));
2740 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
2741 != symcount
* sizeof (Elf_External_Sym
))
2743 free ((PTR
) x_symp
);
2744 bfd_error
= system_call_error
;
2747 /* Skip first symbol, which is a null dummy. */
2748 for (i
= 1; i
< symcount
; i
++)
2750 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
2751 memcpy (&sym
->internal_elf_sym
, &i_sym
, sizeof (Elf_Internal_Sym
));
2752 memcpy (&sym
->native_elf_sym
, x_symp
+ i
, sizeof (Elf_External_Sym
));
2753 sym
->symbol
.the_bfd
= abfd
;
2755 sym
->symbol
.name
= elf_string_from_elf_section (abfd
, hdr
->sh_link
,
2758 sym
->symbol
.value
= i_sym
.st_value
;
2760 /* FIXME -- this is almost certainly bogus. It's from Pace
2761 Willisson's hasty Solaris support, to pass the sizes of
2762 object files or functions down into GDB via the back door, to
2763 circumvent some other kludge in how Sun hacked stabs. --
2765 /* XXX Size is now stored via a pointer in an elf_symbol_type;
2766 should fix gdb then turn this off. */
2767 sym
->symbol
.udata
= (PTR
) i_sym
.st_size
;
2768 /* FIXME -- end of bogosity. */
2770 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
2772 sym
->symbol
.section
= section_from_elf_index (abfd
, i_sym
.st_shndx
);
2774 else if (i_sym
.st_shndx
== SHN_ABS
)
2776 sym
->symbol
.section
= &bfd_abs_section
;
2778 else if (i_sym
.st_shndx
== SHN_COMMON
)
2780 sym
->symbol
.section
= &bfd_com_section
;
2782 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2784 sym
->symbol
.section
= &bfd_und_section
;
2787 sym
->symbol
.section
= &bfd_abs_section
;
2789 sym
->symbol
.value
-= sym
->symbol
.section
->vma
;
2791 switch (ELF_ST_BIND (i_sym
.st_info
))
2794 sym
->symbol
.flags
|= BSF_LOCAL
;
2797 sym
->symbol
.flags
|= (BSF_GLOBAL
| BSF_EXPORT
);
2800 sym
->symbol
.flags
|= BSF_WEAK
;
2804 switch (ELF_ST_TYPE (i_sym
.st_info
))
2807 sym
->symbol
.flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2810 sym
->symbol
.flags
|= BSF_FILE
| BSF_DEBUGGING
;
2813 sym
->symbol
.flags
|= BSF_FUNCTION
;
2816 /* Is this a definition of $global$? If so, keep it because it will be
2817 needd if any relocations are performed. */
2818 if (!strcmp (sym
->symbol
.name
, "$global$")
2819 && sym
->symbol
.section
!= &bfd_und_section
)
2821 /* @@ Why is this referring to backend data and not a field of
2823 struct elf_backend_data
*be_data
= (struct elf_backend_data
*) abfd
->xvec
->backend_data
;
2825 be_data
->global_sym
= sym
;
2830 /* We rely on the zalloc to clear out the final symbol entry. */
2832 obj_raw_syms (abfd
) = x_symp
;
2834 bfd_get_symcount (abfd
) = symcount
= sym
- symbase
;
2836 /* Fill in the user's symbol pointer vector if needed. */
2840 while (symcount
-- > 0)
2842 *symptrs
++ = &sym
->symbol
;
2845 *symptrs
= 0; /* Final null pointer */
2851 /* Return the number of bytes required to hold the symtab vector.
2853 Note that we base it on the count plus 1, since we will null terminate
2854 the vector allocated based on this size. However, the ELF symbol table
2855 always has a dummy entry as symbol #0, so it ends up even. */
2858 DEFUN (elf_get_symtab_upper_bound
, (abfd
), bfd
* abfd
)
2860 unsigned int symcount
;
2861 unsigned int symtab_size
= 0;
2862 Elf_Internal_Shdr
*i_shdrp
;
2863 Elf_Internal_Shdr
*hdr
;
2865 i_shdrp
= elf_elfsections (abfd
);
2866 if (i_shdrp
!= NULL
)
2868 hdr
= i_shdrp
+ elf_onesymtab (abfd
);
2869 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2870 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
));
2876 This function return the number of bytes required to store the
2877 relocation information associated with section <<sect>>
2878 attached to bfd <<abfd>>
2882 elf_get_reloc_upper_bound (abfd
, asect
)
2886 if (asect
->flags
& SEC_RELOC
)
2888 /* either rel or rela */
2889 return asect
->_raw_size
;
2896 DEFUN (elf_slurp_reloca_table
, (abfd
, asect
, symbols
),
2901 Elf_External_Rela
*native_relocs
;
2902 arelent
*reloc_cache
;
2907 if (asect
->relocation
)
2909 if (asect
->reloc_count
== 0)
2911 if (asect
->flags
& SEC_CONSTRUCTOR
)
2914 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2915 native_relocs
= (Elf_External_Rela
*)
2916 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rela
));
2917 bfd_read ((PTR
) native_relocs
,
2918 sizeof (Elf_External_Rela
), asect
->reloc_count
, abfd
);
2920 reloc_cache
= (arelent
*)
2921 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
2925 bfd_error
= no_memory
;
2929 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2931 #ifdef RELOC_PROCESSING
2932 Elf_Internal_Rela dst
;
2933 Elf_External_Rela
*src
;
2935 cache_ptr
= reloc_cache
+ idx
;
2936 src
= native_relocs
+ idx
;
2937 elf_swap_reloca_in (abfd
, src
, &dst
);
2939 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
2941 Elf_Internal_Rela dst
;
2942 Elf_External_Rela
*src
;
2944 cache_ptr
= reloc_cache
+ idx
;
2945 src
= native_relocs
+ idx
;
2947 elf_swap_reloca_in (abfd
, src
, &dst
);
2949 if (asect
->flags
& SEC_RELOC
)
2951 /* relocatable, so the offset is off of the section */
2952 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2956 /* non-relocatable, so the offset a virtual address */
2957 cache_ptr
->address
= dst
.r_offset
;
2959 /* ELF_R_SYM(dst.r_info) is the symbol table offset; subtract 1
2960 because the first entry is NULL. */
2961 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF32_R_SYM (dst
.r_info
) - 1;
2962 cache_ptr
->addend
= dst
.r_addend
;
2964 /* Fill in the cache_ptr->howto field from dst.r_type */
2966 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
2967 (*ebd
->elf_info_to_howto
) (abfd
, cache_ptr
, &dst
);
2972 asect
->relocation
= reloc_cache
;
2978 elf_debug_section (str
, num
, hdr
)
2981 Elf_Internal_Shdr
*hdr
;
2983 fprintf (stderr
, "\nSection#%d '%s' 0x%.8lx\n", num
, str
, (long) hdr
);
2984 fprintf (stderr
, "sh_name = %ld\n", (long) hdr
->sh_name
);
2985 fprintf (stderr
, "sh_type = %ld\n", (long) hdr
->sh_type
);
2986 fprintf (stderr
, "sh_flags = %ld\n", (long) hdr
->sh_flags
);
2987 fprintf (stderr
, "sh_addr = %ld\n", (long) hdr
->sh_addr
);
2988 fprintf (stderr
, "sh_offset = %ld\n", (long) hdr
->sh_offset
);
2989 fprintf (stderr
, "sh_size = %ld\n", (long) hdr
->sh_size
);
2990 fprintf (stderr
, "sh_link = %ld\n", (long) hdr
->sh_link
);
2991 fprintf (stderr
, "sh_info = %ld\n", (long) hdr
->sh_info
);
2992 fprintf (stderr
, "sh_addralign = %ld\n", (long) hdr
->sh_addralign
);
2993 fprintf (stderr
, "sh_entsize = %ld\n", (long) hdr
->sh_entsize
);
2994 fprintf (stderr
, "rawdata = 0x%.8lx\n", (long) hdr
->rawdata
);
2995 fprintf (stderr
, "contents = 0x%.8lx\n", (long) hdr
->contents
);
2996 fprintf (stderr
, "size = %ld\n", (long) hdr
->size
);
3003 DEFUN (elf_slurp_reloc_table
, (abfd
, asect
, symbols
),
3008 Elf_External_Rel
*native_relocs
;
3009 arelent
*reloc_cache
;
3011 Elf_Internal_Shdr
*i_shdrp
;
3012 Elf_Internal_Shdr
*data_hdr
;
3013 ElfNAME (Off
) data_off
;
3014 ElfNAME (Word
) data_max
;
3015 char buf
[4]; /* FIXME -- might be elf64 */
3019 if (asect
->relocation
)
3021 if (asect
->reloc_count
== 0)
3023 if (asect
->flags
& SEC_CONSTRUCTOR
)
3026 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
3027 native_relocs
= (Elf_External_Rel
*)
3028 bfd_alloc (abfd
, asect
->reloc_count
* sizeof (Elf_External_Rel
));
3029 bfd_read ((PTR
) native_relocs
,
3030 sizeof (Elf_External_Rel
), asect
->reloc_count
, abfd
);
3032 reloc_cache
= (arelent
*)
3033 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
3037 bfd_error
= no_memory
;
3041 /* Get the offset of the start of the segment we are relocating to read in
3042 the implicit addend. */
3043 i_shdrp
= elf_elfsections (abfd
);
3044 data_hdr
= i_shdrp
+ elf_section_from_bfd_section (abfd
, asect
);
3045 data_off
= data_hdr
->sh_offset
;
3046 data_max
= data_hdr
->sh_size
- sizeof (buf
) + 1;
3049 elf_debug_section ("data section", data_hdr
- i_shdrp
, data_hdr
);
3052 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
3054 #ifdef RELOC_PROCESSING
3055 Elf_Internal_Rel dst
;
3056 Elf_External_Rel
*src
;
3058 cache_ptr
= reloc_cache
+ idx
;
3059 src
= native_relocs
+ idx
;
3060 elf_swap_reloc_in (abfd
, src
, &dst
);
3062 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
3064 Elf_Internal_Rel dst
;
3065 Elf_External_Rel
*src
;
3067 cache_ptr
= reloc_cache
+ idx
;
3068 src
= native_relocs
+ idx
;
3070 elf_swap_reloc_in (abfd
, src
, &dst
);
3072 if (asect
->flags
& SEC_RELOC
)
3074 /* relocatable, so the offset is off of the section */
3075 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
3079 /* non-relocatable, so the offset a virtual address */
3080 cache_ptr
->address
= dst
.r_offset
;
3082 /* ELF_R_SYM(dst.r_info) is the symbol table offset...
3083 -1 is to skip the dummy symbol table entry */
3084 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF32_R_SYM (dst
.r_info
) - 1;
3085 BFD_ASSERT (dst
.r_offset
<= data_max
);
3086 if (bfd_seek (abfd
, data_off
+ dst
.r_offset
, SEEK_SET
) != 0
3087 || bfd_read ((PTR
) buf
, sizeof (buf
), 1, abfd
) != sizeof (buf
))
3089 bfd_error
= system_call_error
;
3093 cache_ptr
->addend
= (*abfd
->xvec
->bfd_getx_signed_32
) ((bfd_byte
*) buf
);
3095 /* Fill in the cache_ptr->howto field from dst.r_type */
3097 struct elf_backend_data
*ebd
= get_elf_backend_data (abfd
);
3098 (*ebd
->elf_info_to_howto_rel
) (abfd
, cache_ptr
, &dst
);
3103 asect
->relocation
= reloc_cache
;
3108 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
3114 arelent
*tblptr
= section
->relocation
;
3115 unsigned int count
= 0;
3116 int use_rela_p
= get_elf_backend_data (abfd
)->use_rela_p
;
3118 /* snarfed from coffcode.h */
3120 elf_slurp_reloca_table (abfd
, section
, symbols
);
3122 elf_slurp_reloc_table (abfd
, section
, symbols
);
3124 tblptr
= section
->relocation
;
3128 for (; count
++ < section
->reloc_count
;)
3129 *relptr
++ = tblptr
++;
3132 return section
->reloc_count
;
3136 DEFUN (elf_get_symtab
, (abfd
, alocation
),
3138 asymbol
** alocation
)
3141 if (!elf_slurp_symbol_table (abfd
, alocation
))
3144 return bfd_get_symcount (abfd
);
3148 DEFUN (elf_make_empty_symbol
, (abfd
),
3151 elf_symbol_type
*newsym
;
3153 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
3156 bfd_error
= no_memory
;
3161 newsym
->symbol
.the_bfd
= abfd
;
3162 return &newsym
->symbol
;
3167 DEFUN (elf_get_symbol_info
, (ignore_abfd
, symbol
, ret
),
3168 bfd
* ignore_abfd AND
3169 asymbol
* symbol AND
3172 bfd_symbol_info (symbol
, ret
);
3176 DEFUN (elf_print_symbol
, (ignore_abfd
, filep
, symbol
, how
),
3177 bfd
* ignore_abfd AND
3179 asymbol
* symbol AND
3180 bfd_print_symbol_type how
)
3182 FILE *file
= (FILE *) filep
;
3185 case bfd_print_symbol_name
:
3186 fprintf (file
, "%s", symbol
->name
);
3188 case bfd_print_symbol_more
:
3189 fprintf (file
, "elf %lx %lx",
3191 (long) symbol
->flags
);
3193 case bfd_print_symbol_all
:
3195 CONST
char *section_name
;
3196 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
3197 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
3198 fprintf (file
, " %s\t%s",
3208 DEFUN (elf_get_lineno
, (ignore_abfd
, symbol
),
3209 bfd
* ignore_abfd AND
3212 fprintf (stderr
, "elf_get_lineno unimplemented\n");
3219 DEFUN (elf_set_arch_mach
, (abfd
, arch
, machine
),
3221 enum bfd_architecture arch AND
3222 unsigned long machine
)
3224 /* Allow any architecture to be supported by the elf backend */
3227 case bfd_arch_unknown
: /* EM_NONE */
3228 case bfd_arch_sparc
: /* EM_SPARC */
3229 case bfd_arch_i386
: /* EM_386 */
3230 case bfd_arch_m68k
: /* EM_68K */
3231 case bfd_arch_m88k
: /* EM_88K */
3232 case bfd_arch_i860
: /* EM_860 */
3233 case bfd_arch_mips
: /* EM_MIPS (MIPS R3000) */
3234 case bfd_arch_hppa
: /* EM_HPPA (HP PA_RISC) */
3235 return bfd_default_set_arch_mach (abfd
, arch
, machine
);
3242 DEFUN (elf_find_nearest_line
, (abfd
,
3250 asection
* section AND
3251 asymbol
** symbols AND
3253 CONST
char **filename_ptr AND
3254 CONST
char **functionname_ptr AND
3255 unsigned int *line_ptr
)
3257 fprintf (stderr
, "elf_find_nearest_line unimplemented\n");
3264 DEFUN (elf_sizeof_headers
, (abfd
, reloc
),
3268 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
3275 DEFUN (elf_set_section_contents
, (abfd
, section
, location
, offset
, count
),
3280 bfd_size_type count
)
3284 if (abfd
->output_has_begun
== false) /* set by bfd.c handler? */
3286 /* do setup calculations (FIXME) */
3287 elf_compute_section_file_positions (abfd
);
3288 abfd
->output_has_begun
= true;
3291 dest_sect
= elf_section_from_bfd_section (abfd
, section
);
3295 if (bfd_seek (abfd
, elf_elfsections (abfd
)[dest_sect
].sh_offset
+ offset
, SEEK_SET
) == -1)
3297 if (bfd_write (location
, 1, count
, abfd
) != count
)
3303 DEFUN (elf_no_info_to_howto
, (abfd
, cache_ptr
, dst
),
3305 arelent
* cache_ptr AND
3306 Elf_Internal_Rela
* dst
)
3308 fprintf (stderr
, "elf RELA relocation support for target machine unimplemented\n");
3314 DEFUN (elf_no_info_to_howto_rel
, (abfd
, cache_ptr
, dst
),
3316 arelent
* cache_ptr AND
3317 Elf_Internal_Rel
* dst
)
3319 fprintf (stderr
, "elf REL relocation support for target machine unimplemented\n");
3325 DEFUN (elf_get_sect_thunk
, (abfd
, est
),
3327 elf_sect_thunk
* est
)
3329 if (est
== (elf_sect_thunk
*) NULL
)
3332 est
->i_ehdr
= elf_elfheader (abfd
);
3333 est
->i_shdrp
= elf_elfsections (abfd
);
3334 est
->shstrtab
= elf_shstrtab (abfd
);
3335 est
->symtab_section
= elf_onesymtab (abfd
); /* filled in by elf_fake */