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
14 This file is part of BFD, the Binary File Descriptor library.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
31 /****************************************
35 This is only a partial ELF implementation,
36 incorporating only those parts that are
37 required to get gdb up and running. It is
38 expected that it will be expanded to a full
39 ELF implementation at some future date.
41 Unimplemented stubs call abort() to ensure
42 that they get proper attention if they are
43 ever called. The stubs are here since
44 this version was hacked from the COFF
45 version, and thus they will probably
46 go away or get expanded appropriately in a
51 *****************************************/
54 /* Problems and other issues to resolve.
56 (1) BFD expects there to be some fixed number of "sections" in
57 the object file. I.E. there is a "section_count" variable in the
58 bfd structure which contains the number of sections. However, ELF
59 supports multiple "views" of a file. In particular, with current
60 implementations, executable files typically have two tables, a
61 program header table and a section header table, both of which
62 partition the executable.
64 In ELF-speak, the "linking view" of the file uses the section header
65 table to access "sections" within the file, and the "execution view"
66 uses the program header table to access "segments" within the file.
67 "Segments" typically may contain all the data from one or more
70 Note that the section header table is optional in ELF executables,
71 but it is this information that is most useful to gdb. If the
72 section header table is missing, then gdb should probably try
73 to make do with the program header table. (FIXME)
81 #include "elf/common.h"
82 #include "elf/internal.h"
83 #include "elf/external.h"
85 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
86 #include <sys/procfs.h>
88 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
89 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
90 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
93 /* Forward declarations of static functions */
96 elf_read
PARAMS ((bfd
*, long, int));
99 section_from_elf_index
PARAMS ((bfd
*, int));
102 elf_section_from_bfd_section
PARAMS ((bfd
*, struct sec
*));
105 elf_slurp_symbol_table
PARAMS ((bfd
*, asymbol
**));
108 elf_info_to_howto
PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
111 elf_get_str_section
PARAMS ((bfd
*, unsigned int));
113 /* Forward data declarations */
115 extern bfd_target elf_little_vec
, elf_big_vec
;
117 /* Currently the elf_symbol_type struct just contains the generic bfd
125 /* Some private data is stashed away for future use using the tdata pointer
126 in the bfd structure. */
130 Elf_Internal_Ehdr elf_header
[1]; /* Actual data, but ref like ptr */
131 Elf_Internal_Shdr
*elf_sect_ptr
;
132 struct strtab
*strtab_ptr
;
134 void *prstatus
; /* The raw /proc prstatus structure */
135 void *prpsinfo
; /* The raw /proc prpsinfo structure */
138 #define elf_tdata(bfd) ((bfd) -> tdata.elf_obj_data)
139 #define elf_elfheader(bfd) (elf_tdata(bfd) -> elf_header)
140 #define elf_elfsections(bfd) (elf_tdata(bfd) -> elf_sect_ptr)
141 #define elf_shstrtab(bfd) (elf_tdata(bfd) -> strtab_ptr)
142 #define elf_onesymtab(bfd) (elf_tdata(bfd) -> symtab_section)
143 #define core_prpsinfo(bfd) (elf_tdata(bfd) -> prpsinfo)
144 #define core_prstatus(bfd) (elf_tdata(bfd) -> prstatus)
146 /* Translate an ELF symbol in external format into an ELF symbol in internal
150 DEFUN(elf_swap_symbol_in
,(abfd
, src
, dst
),
152 Elf_External_Sym
*src AND
153 Elf_Internal_Sym
*dst
)
155 dst
-> st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> st_name
);
156 dst
-> st_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> st_value
);
157 dst
-> st_size
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> st_size
);
158 dst
-> st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
-> st_info
);
159 dst
-> st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
-> st_other
);
160 dst
-> st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> st_shndx
);
163 /* Translate an ELF symbol in internal format into an ELF symbol in external
167 DEFUN(elf_swap_symbol_out
,(abfd
, src
, dst
),
169 Elf_Internal_Sym
*src AND
170 Elf_External_Sym
*dst
)
172 bfd_h_put_32 (abfd
, src
->st_name
, dst
->st_name
);
173 bfd_h_put_32 (abfd
, src
->st_value
, dst
->st_value
);
174 bfd_h_put_32 (abfd
, src
->st_size
, dst
->st_size
);
175 bfd_h_put_8 (abfd
, src
->st_info
, dst
->st_info
);
176 bfd_h_put_8 (abfd
, src
->st_other
, dst
->st_other
);
177 bfd_h_put_16 (abfd
, src
->st_shndx
, dst
->st_shndx
);
181 /* Translate an ELF file header in external format into an ELF file header in
185 DEFUN(elf_swap_ehdr_in
,(abfd
, src
, dst
),
187 Elf_External_Ehdr
*src AND
188 Elf_Internal_Ehdr
*dst
)
190 memcpy (dst
-> e_ident
, src
-> e_ident
, EI_NIDENT
);
191 dst
-> e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_type
);
192 dst
-> e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_machine
);
193 dst
-> e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_version
);
194 dst
-> e_entry
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_entry
);
195 dst
-> e_phoff
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_phoff
);
196 dst
-> e_shoff
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_shoff
);
197 dst
-> e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_flags
);
198 dst
-> e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_ehsize
);
199 dst
-> e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_phentsize
);
200 dst
-> e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_phnum
);
201 dst
-> e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_shentsize
);
202 dst
-> e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_shnum
);
203 dst
-> e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_shstrndx
);
206 /* Translate an ELF file header in internal format into an ELF file header in
210 DEFUN(elf_swap_ehdr_out
,(abfd
, src
, dst
),
212 Elf_Internal_Ehdr
*src AND
213 Elf_External_Ehdr
*dst
)
215 memcpy (dst
-> e_ident
, src
-> e_ident
, EI_NIDENT
);
216 /* note that all elements of dst are *arrays of unsigned char* already... */
217 bfd_h_put_16 (abfd
, src
->e_type
, dst
->e_type
);
218 bfd_h_put_16 (abfd
, src
->e_machine
, dst
->e_machine
);
219 bfd_h_put_32 (abfd
, src
->e_version
, dst
->e_version
);
220 bfd_h_put_32 (abfd
, src
->e_entry
, dst
->e_entry
);
221 bfd_h_put_32 (abfd
, src
->e_phoff
, dst
->e_phoff
);
222 bfd_h_put_32 (abfd
, src
->e_shoff
, dst
->e_shoff
);
223 bfd_h_put_32 (abfd
, src
->e_flags
, dst
->e_flags
);
224 bfd_h_put_16 (abfd
, src
->e_ehsize
, dst
->e_ehsize
);
225 bfd_h_put_16 (abfd
, src
->e_phentsize
, dst
->e_phentsize
);
226 bfd_h_put_16 (abfd
, src
->e_phnum
, dst
->e_phnum
);
227 bfd_h_put_16 (abfd
, src
->e_shentsize
, dst
->e_shentsize
);
228 bfd_h_put_16 (abfd
, src
->e_shnum
, dst
->e_shnum
);
229 bfd_h_put_16 (abfd
, src
->e_shstrndx
, dst
->e_shstrndx
);
233 /* Translate an ELF section header table entry in external format into an
234 ELF section header table entry in internal format. */
237 DEFUN(elf_swap_shdr_in
,(abfd
, src
, dst
),
239 Elf_External_Shdr
*src AND
240 Elf_Internal_Shdr
*dst
)
242 dst
->sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_name
);
243 dst
->sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_type
);
244 dst
->sh_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_flags
);
245 dst
->sh_addr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_addr
);
246 dst
->sh_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_offset
);
247 dst
->sh_size
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_size
);
248 dst
->sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_link
);
249 dst
->sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_info
);
250 dst
->sh_addralign
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_addralign
);
251 dst
->sh_entsize
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->sh_entsize
);
252 /* we haven't done any processing on it yet, so... */
253 dst
->rawdata
= (void*)0;
256 /* Translate an ELF section header table entry in internal format into an
257 ELF section header table entry in external format. */
260 DEFUN(elf_swap_shdr_out
,(abfd
, src
, dst
),
262 Elf_Internal_Shdr
*src AND
263 Elf_External_Shdr
*dst
)
265 /* note that all elements of dst are *arrays of unsigned char* already... */
266 bfd_h_put_32 (abfd
, src
->sh_name
, dst
->sh_name
);
267 bfd_h_put_32 (abfd
, src
->sh_type
, dst
->sh_type
);
268 bfd_h_put_32 (abfd
, src
->sh_flags
, dst
->sh_flags
);
269 bfd_h_put_32 (abfd
, src
->sh_addr
, dst
->sh_addr
);
270 bfd_h_put_32 (abfd
, src
->sh_offset
, dst
->sh_offset
);
271 bfd_h_put_32 (abfd
, src
->sh_size
, dst
->sh_size
);
272 bfd_h_put_32 (abfd
, src
->sh_link
, dst
->sh_link
);
273 bfd_h_put_32 (abfd
, src
->sh_info
, dst
->sh_info
);
274 bfd_h_put_32 (abfd
, src
->sh_addralign
, dst
->sh_addralign
);
275 bfd_h_put_32 (abfd
, src
->sh_entsize
, dst
->sh_entsize
);
279 /* Translate an ELF program header table entry in external format into an
280 ELF program header table entry in internal format. */
283 DEFUN(elf_swap_phdr_in
,(abfd
, src
, dst
),
285 Elf_External_Phdr
*src AND
286 Elf_Internal_Phdr
*dst
)
288 dst
->p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_type
);
289 dst
->p_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_offset
);
290 dst
->p_vaddr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_vaddr
);
291 dst
->p_paddr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_paddr
);
292 dst
->p_filesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_filesz
);
293 dst
->p_memsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_memsz
);
294 dst
->p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_flags
);
295 dst
->p_align
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->p_align
);
299 /* Translate an ELF reloc from external format to internal format. */
301 DEFUN(elf_swap_reloc_in
,(abfd
, src
, dst
),
303 Elf_External_Rel
*src AND
304 Elf_Internal_Rel
*dst
)
306 dst
->r_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_offset
);
307 dst
->r_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_info
);
311 DEFUN(elf_swap_reloca_in
,(abfd
, src
, dst
),
313 Elf_External_Rela
*src AND
314 Elf_Internal_Rela
*dst
)
316 dst
->r_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_offset
);
317 dst
->r_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_info
);
318 dst
->r_addend
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
->r_addend
);
321 /* Translate an ELF reloc from internal format to external format. */
323 DEFUN(elf_swap_reloc_out
,(abfd
, src
, dst
),
325 Elf_Internal_Rel
*src AND
326 Elf_External_Rel
*dst
)
328 bfd_h_put_32 (abfd
, src
->r_offset
, dst
->r_offset
);
329 bfd_h_put_32 (abfd
, src
->r_info
, dst
->r_info
);
333 DEFUN(elf_swap_reloca_out
,(abfd
, src
, dst
),
335 Elf_Internal_Rela
*src AND
336 Elf_External_Rela
*dst
)
338 bfd_h_put_32 (abfd
, src
->r_offset
, dst
->r_offset
);
339 bfd_h_put_32 (abfd
, src
->r_info
, dst
->r_info
);
340 bfd_h_put_32 (abfd
, src
->r_addend
, dst
->r_addend
);
348 struct elf_internal_shdr *bfd_elf_find_section (bfd *abfd, char *name);
351 Helper functions for GDB to locate the string tables.
352 Since BFD hides string tables from callers, GDB needs to use an
353 internal hook to find them. Sun's .stabstr, in particular,
354 isn't even pointed to by the .stab section, so ordinary
355 mechanisms wouldn't work to find it, even if we had some.
358 struct elf_internal_shdr
*
359 DEFUN(bfd_elf_find_section
, (abfd
, name
),
363 Elf_Internal_Shdr
*i_shdrp
;
364 Elf_Internal_Shdr
*gotit
= NULL
;
369 i_shdrp
= elf_elfsections (abfd
);
372 shstrtab
= elf_get_str_section (abfd
, elf_elfheader (abfd
)->e_shstrndx
);
373 if (shstrtab
!= NULL
)
375 max
= elf_elfheader (abfd
)->e_shnum
;
376 for (i
= 1; i
< max
; i
++)
378 if (!strcmp (&shstrtab
[i_shdrp
[i
].sh_name
], name
))
388 /* End of GDB support. */
391 DEFUN(elf_get_str_section
, (abfd
, shindex
),
393 unsigned int shindex
)
395 Elf_Internal_Shdr
*i_shdrp
;
396 char *shstrtab
= NULL
;
398 unsigned int shstrtabsize
;
400 i_shdrp
= elf_elfsections (abfd
);
403 shstrtab
= i_shdrp
[shindex
].rawdata
;
404 if (shstrtab
== NULL
)
406 /* No cached one, attempt to read, and cache what we read. */
407 offset
= i_shdrp
[shindex
].sh_offset
;
408 shstrtabsize
= i_shdrp
[shindex
].sh_size
;
409 shstrtab
= elf_read (abfd
, offset
, shstrtabsize
);
410 i_shdrp
[shindex
].rawdata
= (void*) shstrtab
;
417 DEFUN(elf_string_from_elf_section
, (abfd
, shindex
, strindex
),
419 unsigned int shindex AND
420 unsigned int strindex
)
422 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
423 Elf_Internal_Shdr
*hdr
= i_shdrp
+ shindex
;
427 if (elf_get_str_section (abfd
, shindex
) == NULL
)
432 return ((char*)hdr
->rawdata
)+strindex
;
435 #define elf_string_from_elf_strtab(abfd, strindex) \
436 elf_string_from_elf_section (abfd, elf_elfheader(abfd)->e_shstrndx, strindex)
438 /* Create a new bfd section from an ELF section header. */
441 DEFUN(bfd_section_from_shdr
, (abfd
, shindex
),
443 unsigned int shindex
)
445 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
446 Elf_Internal_Shdr
*hdr
= i_shdrp
+ shindex
;
450 name
= hdr
->sh_name
?
451 elf_string_from_elf_strtab (abfd
, hdr
->sh_name
) : "unnamed";
453 switch(hdr
->sh_type
) {
456 /* inactive section. Throw it away. */
461 /* Bits that get saved. This one is real. */
464 newsect
= bfd_make_section (abfd
, name
);
465 newsect
->vma
= hdr
->sh_addr
;
466 newsect
->_raw_size
= hdr
->sh_size
;
467 newsect
->filepos
= hdr
->sh_offset
; /* so we can read back the bits */
468 newsect
->flags
|= SEC_HAS_CONTENTS
;
470 if (hdr
->sh_flags
& SHF_ALLOC
)
472 newsect
->flags
|= SEC_ALLOC
;
473 if (hdr
->sh_type
!= SHT_NOBITS
)
474 newsect
->flags
|= SEC_LOAD
;
477 if (!(hdr
->sh_flags
& SHF_WRITE
))
478 newsect
->flags
|= SEC_READONLY
;
480 if (hdr
->sh_flags
& SHF_EXECINSTR
)
481 newsect
->flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
483 newsect
->flags
|= SEC_DATA
;
485 hdr
->rawdata
= (void*)newsect
;
490 case SHT_SYMTAB
: /* A symbol table */
491 BFD_ASSERT (hdr
->sh_entsize
== sizeof (Elf_External_Sym
));
492 elf_onesymtab (abfd
) = shindex
;
493 abfd
->flags
|= HAS_SYMS
;
496 case SHT_STRTAB
: /* A string table */
501 /* *these* do a lot of work -- but build no sections! */
502 /* the spec says there can be multiple strtabs, but only one symtab */
503 /* but there can be lots of REL* sections. */
504 /* FIXME: The above statement is wrong! There are typically at least
505 two symbol tables in a dynamically linked executable, ".dynsym"
506 which is the dynamic linkage symbol table and ".symtab", which is
507 the "traditional" symbol table. -fnf */
510 asection
*target_sect
;
512 bfd_section_from_shdr (abfd
, hdr
->sh_link
); /* symbol table */
513 bfd_section_from_shdr (abfd
, hdr
->sh_info
); /* target */
514 target_sect
= section_from_elf_index (abfd
, hdr
->sh_info
);
515 if (target_sect
== NULL
)
519 /* FIXME: We are only prepared to read one symbol table, so
520 do NOT read the dynamic symbol table since it is only a
521 subset of the full symbol table. Also see comment above. -fnf */
522 if (!elf_slurp_symbol_table(abfd
, i_shdrp
+ hdr
->sh_link
))
526 target_sect
->reloc_count
= hdr
->sh_size
/ hdr
->sh_entsize
;
527 target_sect
->flags
|= SEC_RELOC
;
528 target_sect
->relocation
= 0;
529 target_sect
->rel_filepos
= hdr
->sh_offset
;
536 case SHT_DYNSYM
: /* could treat this like symtab... */
538 fprintf(stderr
, "Dynamic Linking sections not yet supported.\n");
545 fprintf(stderr
, "Note Sections not yet supported.\n");
552 fprintf(stderr
, "SHLIB Sections not supported (and non conforming.)\n");
573 static struct strtab
*
574 DEFUN(bfd_new_strtab
, (abfd
),
579 ss
= (struct strtab
*) bfd_xmalloc(sizeof(struct strtab
));
580 ss
->tab
= bfd_xmalloc(1);
581 BFD_ASSERT(ss
->tab
!= 0);
590 DEFUN(bfd_add_to_strtab
, (abfd
, ss
, str
),
592 struct strtab
*ss AND
595 /* should search first, but for now: */
596 /* include the trailing NUL */
597 int ln
= strlen(str
)+1;
599 /* should this be using obstacks? */
600 ss
->tab
= realloc(ss
->tab
, ss
->length
+ ln
);
602 BFD_ASSERT(ss
->tab
!= 0);
603 strcpy(ss
->tab
+ ss
->length
, str
);
607 return ss
->length
- ln
;
611 DEFUN(bfd_add_2_to_strtab
, (abfd
, ss
, str
, str2
),
613 struct strtab
*ss AND
617 /* should search first, but for now: */
618 /* include the trailing NUL */
619 int ln
= strlen(str
)+strlen(str2
)+1;
621 /* should this be using obstacks? */
623 ss
->tab
= realloc(ss
->tab
, ss
->length
+ ln
);
625 ss
->tab
= bfd_xmalloc(ln
);
627 BFD_ASSERT(ss
->tab
!= 0);
628 strcpy(ss
->tab
+ ss
->length
, str
);
629 strcpy(ss
->tab
+ ss
->length
+ strlen(str
), str2
);
633 return ss
->length
- ln
;
636 /* Create a new ELF section from a bfd section. */
639 DEFUN(bfd_shdr_from_section
, (abfd
, hdr
, shstrtab
, indx
),
641 Elf_Internal_Shdr
*hdr AND
642 struct strtab
*shstrtab AND
648 /* figure out out to write the section name from the bfd section name. MWE */
650 sect
= abfd
->sections
;
651 for (ndx
= indx
; --ndx
; )
655 hdr
[indx
].sh_name
= bfd_add_to_strtab(abfd
, shstrtab
,
656 bfd_section_name(abfd
, sect
));
657 hdr
[indx
].sh_addr
= sect
->vma
;
658 hdr
[indx
].sh_size
= sect
->_raw_size
;
659 hdr
[indx
].sh_flags
= 0;
660 /* these need to be preserved on */
661 hdr
[indx
].sh_link
= 0;
662 hdr
[indx
].sh_info
= 0;
663 hdr
[indx
].sh_addralign
= 0;
664 hdr
[indx
].sh_entsize
= 0;
666 hdr
[indx
].sh_type
= 0;
667 if (sect
->flags
& SEC_RELOC
) {
668 hdr
[indx
].sh_type
= SHT_RELA
; /* FIXME -- sparc specific */
671 if (sect
->flags
& SEC_HAS_CONTENTS
)
673 hdr
[indx
].sh_offset
= sect
->filepos
;
674 hdr
[indx
].sh_size
= sect
->_raw_size
;
676 if (sect
->flags
& SEC_ALLOC
)
678 hdr
[indx
].sh_flags
|= SHF_ALLOC
;
679 if (sect
->flags
& SEC_LOAD
)
681 /* do something with sh_type ? */
684 if (!(sect
->flags
& SEC_READONLY
))
685 hdr
[indx
].sh_flags
|= SHF_WRITE
;
687 if (sect
->flags
& SEC_CODE
)
688 hdr
[indx
].sh_flags
|= SHF_EXECINSTR
;
693 /* Create a new bfd section from an ELF program header.
695 Since program segments have no names, we generate a synthetic name
696 of the form segment<NUM>, where NUM is generally the index in the
697 program header table. For segments that are split (see below) we
698 generate the names segment<NUM>a and segment<NUM>b.
700 Note that some program segments may have a file size that is different than
701 (less than) the memory size. All this means is that at execution the
702 system must allocate the amount of memory specified by the memory size,
703 but only initialize it with the first "file size" bytes read from the
704 file. This would occur for example, with program segments consisting
705 of combined data+bss.
707 To handle the above situation, this routine generates TWO bfd sections
708 for the single program segment. The first has the length specified by
709 the file size of the segment, and the second has the length specified
710 by the difference between the two sizes. In effect, the segment is split
711 into it's initialized and uninitialized parts.
716 DEFUN(bfd_section_from_phdr
, (abfd
, hdr
, index
),
718 Elf_Internal_Phdr
*hdr AND
726 split
= ((hdr
-> p_memsz
> 0) &&
727 (hdr
-> p_filesz
> 0) &&
728 (hdr
-> p_memsz
> hdr
-> p_filesz
));
729 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
730 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
731 strcpy (name
, namebuf
);
732 newsect
= bfd_make_section (abfd
, name
);
733 newsect
-> vma
= hdr
-> p_vaddr
;
734 newsect
-> _raw_size
= hdr
-> p_filesz
;
735 newsect
-> filepos
= hdr
-> p_offset
;
736 newsect
-> flags
|= SEC_HAS_CONTENTS
;
737 if (hdr
-> p_type
== PT_LOAD
)
739 newsect
-> flags
|= SEC_ALLOC
;
740 newsect
-> flags
|= SEC_LOAD
;
741 if (hdr
-> p_flags
& PF_X
)
743 /* FIXME: all we known is that it has execute PERMISSION,
745 newsect
-> flags
|= SEC_CODE
;
748 if (!(hdr
-> p_flags
& PF_W
))
750 newsect
-> flags
|= SEC_READONLY
;
755 sprintf (namebuf
, "segment%db", index
);
756 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
757 strcpy (name
, namebuf
);
758 newsect
= bfd_make_section (abfd
, name
);
759 newsect
-> vma
= hdr
-> p_vaddr
+ hdr
-> p_filesz
;
760 newsect
-> _raw_size
= hdr
-> p_memsz
- hdr
-> p_filesz
;
761 if (hdr
-> p_type
== PT_LOAD
)
763 newsect
-> flags
|= SEC_ALLOC
;
764 if (hdr
-> p_flags
& PF_X
)
765 newsect
-> flags
|= SEC_CODE
;
767 if (!(hdr
-> p_flags
& PF_W
))
768 newsect
-> flags
|= SEC_READONLY
;
777 DEFUN(bfd_prstatus
,(abfd
, descdata
, descsz
, filepos
),
784 prstatus_t
*status
= (prstatus_t
*)0;
786 if (descsz
== sizeof (prstatus_t
))
788 newsect
= bfd_make_section (abfd
, ".reg");
789 newsect
-> _raw_size
= sizeof (status
->pr_reg
);
790 newsect
-> filepos
= filepos
+ (long) &status
->pr_reg
;
791 newsect
-> flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
792 newsect
-> alignment_power
= 2;
793 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
795 memcpy (core_prstatus (abfd
), descdata
, descsz
);
800 /* Stash a copy of the prpsinfo structure away for future use. */
803 DEFUN(bfd_prpsinfo
,(abfd
, descdata
, descsz
, filepos
),
811 if (descsz
== sizeof (prpsinfo_t
))
813 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
815 memcpy (core_prpsinfo (abfd
), descdata
, descsz
);
821 DEFUN(bfd_fpregset
,(abfd
, descdata
, descsz
, filepos
),
829 newsect
= bfd_make_section (abfd
, ".reg2");
830 newsect
-> _raw_size
= descsz
;
831 newsect
-> filepos
= filepos
;
832 newsect
-> flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
833 newsect
-> alignment_power
= 2;
836 #endif /* HAVE_PROCFS */
838 /* Return a pointer to the args (including the command name) that were
839 seen by the program that generated the core dump. Note that for
840 some reason, a spurious space is tacked onto the end of the args
841 in some (at least one anyway) implementations, so strip it off if
845 DEFUN(elf_core_file_failing_command
, (abfd
),
849 if (core_prpsinfo (abfd
))
851 prpsinfo_t
*p
= core_prpsinfo (abfd
);
852 char *scan
= p
-> pr_psargs
;
855 if ((scan
> p
-> pr_psargs
) && (*scan
== ' '))
859 return (p
-> pr_psargs
);
865 /* Return the number of the signal that caused the core dump. Presumably,
866 since we have a core file, we got a signal of some kind, so don't bother
867 checking the other process status fields, just return the signal number.
871 DEFUN(elf_core_file_failing_signal
, (abfd
),
875 if (core_prstatus (abfd
))
877 return (((prstatus_t
*)(core_prstatus (abfd
))) -> pr_cursig
);
883 /* Check to see if the core file could reasonably be expected to have
884 come for the current executable file. Note that by default we return
885 true unless we find something that indicates that there might be a
890 DEFUN(elf_core_file_matches_executable_p
, (core_bfd
, exec_bfd
),
899 /* First, xvecs must match since both are ELF files for the same target. */
901 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
903 bfd_error
= system_call_error
;
909 /* If no prpsinfo, just return true. Otherwise, grab the last component
910 of the exec'd pathname from the prpsinfo. */
912 if (core_prpsinfo (core_bfd
))
914 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
)) -> pr_fname
);
921 /* Find the last component of the executable pathname. */
923 if ((execname
= strrchr (exec_bfd
-> filename
, '/')) != NULL
)
929 execname
= (char *) exec_bfd
-> filename
;
932 /* See if they match */
934 return (strcmp (execname
, corename
) ? false : true);
940 #endif /* HAVE_PROCFS */
943 /* ELF core files contain a segment of type PT_NOTE, that holds much of
944 the information that would normally be available from the /proc interface
945 for the process, at the time the process dumped core. Currently this
946 includes copies of the prstatus, prpsinfo, and fpregset structures.
948 Since these structures are potentially machine dependent in size and
949 ordering, bfd provides two levels of support for them. The first level,
950 available on all machines since it does not require that the host
951 have /proc support or the relevant include files, is to create a bfd
952 section for each of the prstatus, prpsinfo, and fpregset structures,
953 without any interpretation of their contents. With just this support,
954 the bfd client will have to interpret the structures itself. Even with
955 /proc support, it might want these full structures for it's own reasons.
957 In the second level of support, where HAVE_PROCFS is defined, bfd will
958 pick apart the structures to gather some additional information that
959 clients may want, such as the general register set, the name of the
960 exec'ed file and its arguments, the signal (if any) that caused the
966 DEFUN(elf_corefile_note
, (abfd
, hdr
),
968 Elf_Internal_Phdr
*hdr
)
970 Elf_External_Note
*x_note_p
; /* Elf note, external form */
971 Elf_Internal_Note i_note
; /* Elf note, internal form */
972 char *buf
= NULL
; /* Entire note segment contents */
973 char *namedata
; /* Name portion of the note */
974 char *descdata
; /* Descriptor portion of the note */
975 char *sectname
; /* Name to use for new section */
976 long filepos
; /* File offset to descriptor data */
979 if (hdr
-> p_filesz
> 0
980 && (buf
= (char *) bfd_xmalloc (hdr
-> p_filesz
)) != NULL
981 && bfd_seek (abfd
, hdr
-> p_offset
, SEEK_SET
) != -1
982 && bfd_read ((PTR
) buf
, hdr
-> p_filesz
, 1, abfd
) == hdr
-> p_filesz
)
984 x_note_p
= (Elf_External_Note
*) buf
;
985 while ((char *) x_note_p
< (buf
+ hdr
-> p_filesz
))
987 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
-> namesz
);
988 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
-> descsz
);
989 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
-> type
);
990 namedata
= x_note_p
-> name
;
991 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
992 filepos
= hdr
-> p_offset
+ (descdata
- buf
);
993 switch (i_note
.type
) {
995 /* process descdata as prstatus info */
996 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
997 sectname
= ".prstatus";
1000 /* process descdata as fpregset info */
1001 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
1002 sectname
= ".fpregset";
1005 /* process descdata as prpsinfo */
1006 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
1007 sectname
= ".prpsinfo";
1010 /* Unknown descriptor, just ignore it. */
1014 if (sectname
!= NULL
)
1016 newsect
= bfd_make_section (abfd
, sectname
);
1017 newsect
-> _raw_size
= i_note
.descsz
;
1018 newsect
-> filepos
= filepos
;
1019 newsect
-> flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
1020 newsect
-> alignment_power
= 2;
1022 x_note_p
= (Elf_External_Note
*)
1023 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
1035 /* Read a specified number of bytes at a specified offset in an ELF
1036 file, into a newly allocated buffer, and return a pointer to the
1040 DEFUN(elf_read
, (abfd
, offset
, size
),
1047 if ((buf
= bfd_alloc (abfd
, size
)) == NULL
)
1049 bfd_error
= no_memory
;
1052 if (bfd_seek (abfd
, offset
, SEEK_SET
) == -1)
1054 bfd_error
= system_call_error
;
1057 if (bfd_read ((PTR
) buf
, size
, 1, abfd
) != size
)
1059 bfd_error
= system_call_error
;
1065 /* Begin processing a given object.
1067 First we validate the file by reading in the ELF header and checking
1073 DEFUN (elf_object_p
, (abfd
), bfd
*abfd
)
1075 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1076 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1077 Elf_External_Shdr x_shdr
; /* Section header table entry, external form */
1078 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
1080 char *shstrtab
; /* Internal copy of section header stringtab */
1082 /* Read in the ELF header in external format. */
1084 if (bfd_read ((PTR
) &x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
1086 bfd_error
= system_call_error
;
1090 /* Now check to see if we have a valid ELF file, and one that BFD can
1091 make use of. The magic number must match, the address size ('class')
1092 and byte-swapping must match our XVEC entry, and it must have a
1093 section header table (FIXME: See comments re sections at top of this
1096 if (x_ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
||
1097 x_ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
||
1098 x_ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
||
1099 x_ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
1102 bfd_error
= wrong_format
;
1106 /* FIXME, Check EI_VERSION here ! */
1108 switch (x_ehdr
.e_ident
[EI_CLASS
])
1110 case ELFCLASSNONE
: /* address size not specified */
1111 goto wrong
; /* No support if can't tell address size */
1112 case ELFCLASS32
: /* 32-bit addresses */
1114 case ELFCLASS64
: /* 64-bit addresses */
1115 goto wrong
; /* FIXME: 64 bits not yet supported */
1117 goto wrong
; /* No support if unknown address class */
1120 /* Switch xvec to match the specified byte order. */
1121 switch (x_ehdr
.e_ident
[EI_DATA
])
1123 case ELFDATA2MSB
: /* Big-endian */
1124 if (!abfd
->xvec
->header_byteorder_big_p
)
1127 case ELFDATA2LSB
: /* Little-endian */
1128 if (abfd
->xvec
->header_byteorder_big_p
)
1131 case ELFDATANONE
: /* No data encoding specified */
1132 default: /* Unknown data encoding specified */
1136 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
1137 the tdata pointer in the bfd. */
1139 if (NULL
== (elf_tdata (abfd
) = (struct elf_obj_tdata
*)
1140 bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
))))
1142 bfd_error
= no_memory
;
1146 /* FIXME: Any `wrong' exits below here will leak memory (tdata). */
1148 /* Now that we know the byte order, swap in the rest of the header */
1149 i_ehdrp
= elf_elfheader (abfd
);
1150 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
1152 /* If there is no section header table, we're hosed. */
1153 if (i_ehdrp
->e_shoff
== 0)
1156 if (i_ehdrp
->e_type
== ET_EXEC
|| i_ehdrp
->e_type
== ET_DYN
)
1157 abfd
-> flags
|= EXEC_P
;
1159 switch (i_ehdrp
->e_machine
)
1162 case EM_M32
: /* or should this be bfd_arch_obscure? */
1163 bfd_default_set_arch_mach(abfd
, bfd_arch_unknown
, 0);
1166 bfd_default_set_arch_mach(abfd
, bfd_arch_sparc
, 0);
1169 bfd_default_set_arch_mach(abfd
, bfd_arch_i386
, 0);
1172 bfd_default_set_arch_mach(abfd
, bfd_arch_m68k
, 0);
1175 bfd_default_set_arch_mach(abfd
, bfd_arch_m88k
, 0);
1178 bfd_default_set_arch_mach(abfd
, bfd_arch_i860
, 0);
1181 bfd_default_set_arch_mach(abfd
, bfd_arch_mips
, 0);
1187 /* Allocate space for a copy of the section header table in
1188 internal form, seek to the section header table in the file,
1189 read it in, and convert it to internal form. As a simple sanity
1190 check, verify that the what BFD thinks is the size of each section
1191 header table entry actually matches the size recorded in the file. */
1193 if (i_ehdrp
->e_shentsize
!= sizeof (x_shdr
))
1195 i_shdrp
= (Elf_Internal_Shdr
*)
1196 bfd_alloc (abfd
, sizeof (*i_shdrp
) * i_ehdrp
->e_shnum
);
1199 bfd_error
= no_memory
;
1202 if (bfd_seek (abfd
, i_ehdrp
->e_shoff
, SEEK_SET
) == -1)
1204 bfd_error
= system_call_error
;
1207 for (shindex
= 0; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1209 if (bfd_read ((PTR
) &x_shdr
, sizeof x_shdr
, 1, abfd
)
1212 bfd_error
= system_call_error
;
1215 elf_swap_shdr_in (abfd
, &x_shdr
, i_shdrp
+ shindex
);
1218 elf_elfsections (abfd
) = i_shdrp
;
1220 /* Read in the string table containing the names of the sections. We
1221 will need the base pointer to this table later. */
1222 /* We read this inline now, so that we don't have to go through
1223 bfd_section_from_shdr with it (since this particular strtab is
1224 used to find all of the ELF section names.) */
1226 shstrtab
= elf_get_str_section (abfd
, i_ehdrp
->e_shstrndx
);
1230 /* Once all of the section headers have been read and converted, we
1231 can start processing them. Note that the first section header is
1232 a dummy placeholder entry, so we ignore it.
1234 We also watch for the symbol table section and remember the file
1235 offset and section size for both the symbol table section and the
1236 associated string table section. */
1238 for (shindex
= 1; shindex
< i_ehdrp
->e_shnum
; shindex
++)
1240 bfd_section_from_shdr (abfd
, shindex
);
1243 /* Remember the entry point specified in the ELF file header. */
1245 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
1247 return (abfd
->xvec
);
1250 /* Core files are simply standard ELF formatted files that partition
1251 the file using the execution view of the file (program header table)
1252 rather than the linking view. In fact, there is no section header
1253 table in a core file.
1255 The process status information (including the contents of the general
1256 register set) and the floating point register set are stored in a
1257 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
1258 that allow standard bfd access to the general registers (.reg) and the
1259 floating point registers (.reg2).
1264 DEFUN (elf_core_file_p
, (abfd
), bfd
*abfd
)
1266 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1267 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1268 Elf_External_Phdr x_phdr
; /* Program header table entry, external form */
1269 Elf_Internal_Phdr
*i_phdrp
; /* Program header table, internal form */
1270 unsigned int phindex
;
1272 /* Read in the ELF header in external format. */
1274 if (bfd_read ((PTR
) &x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
1276 bfd_error
= system_call_error
;
1280 /* Now check to see if we have a valid ELF file, and one that BFD can
1281 make use of. The magic number must match, the address size ('class')
1282 and byte-swapping must match our XVEC entry, and it must have a
1283 program header table (FIXME: See comments re segments at top of this
1286 if (x_ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
||
1287 x_ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
||
1288 x_ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
||
1289 x_ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
1292 bfd_error
= wrong_format
;
1296 /* FIXME, Check EI_VERSION here ! */
1298 switch (x_ehdr
.e_ident
[EI_CLASS
])
1300 case ELFCLASSNONE
: /* address size not specified */
1301 goto wrong
; /* No support if can't tell address size */
1302 case ELFCLASS32
: /* 32-bit addresses */
1304 case ELFCLASS64
: /* 64-bit addresses */
1305 goto wrong
; /* FIXME: 64 bits not yet supported */
1307 goto wrong
; /* No support if unknown address class */
1310 /* Switch xvec to match the specified byte order. */
1311 switch (x_ehdr
.e_ident
[EI_DATA
])
1313 case ELFDATA2MSB
: /* Big-endian */
1314 abfd
->xvec
= &elf_big_vec
;
1316 case ELFDATA2LSB
: /* Little-endian */
1317 abfd
->xvec
= &elf_little_vec
;
1319 case ELFDATANONE
: /* No data encoding specified */
1320 default: /* Unknown data encoding specified */
1324 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
1325 the tdata pointer in the bfd. */
1328 (struct elf_obj_tdata
*) bfd_zalloc (abfd
, sizeof (struct elf_obj_tdata
));
1329 if (elf_tdata (abfd
) == NULL
)
1331 bfd_error
= no_memory
;
1335 /* FIXME, `wrong' returns from this point onward, leak memory. */
1337 /* Now that we know the byte order, swap in the rest of the header */
1338 i_ehdrp
= elf_elfheader (abfd
);
1339 elf_swap_ehdr_in (abfd
, &x_ehdr
, i_ehdrp
);
1341 /* If there is no program header, or the type is not a core file, then
1343 if (i_ehdrp
->e_phoff
== 0 || i_ehdrp
->e_type
!= ET_CORE
)
1346 /* Allocate space for a copy of the program header table in
1347 internal form, seek to the program header table in the file,
1348 read it in, and convert it to internal form. As a simple sanity
1349 check, verify that the what BFD thinks is the size of each program
1350 header table entry actually matches the size recorded in the file. */
1352 if (i_ehdrp
->e_phentsize
!= sizeof (x_phdr
))
1354 i_phdrp
= (Elf_Internal_Phdr
*)
1355 bfd_alloc (abfd
, sizeof (*i_phdrp
) * i_ehdrp
->e_phnum
);
1358 bfd_error
= no_memory
;
1361 if (bfd_seek (abfd
, i_ehdrp
->e_phoff
, SEEK_SET
) == -1)
1363 bfd_error
= system_call_error
;
1366 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
1368 if (bfd_read ((PTR
) &x_phdr
, sizeof (x_phdr
), 1, abfd
)
1371 bfd_error
= system_call_error
;
1374 elf_swap_phdr_in (abfd
, &x_phdr
, i_phdrp
+ phindex
);
1377 /* Once all of the program headers have been read and converted, we
1378 can start processing them. */
1380 for (phindex
= 0; phindex
< i_ehdrp
->e_phnum
; phindex
++)
1382 bfd_section_from_phdr (abfd
, i_phdrp
+ phindex
, phindex
);
1383 if ((i_phdrp
+ phindex
) -> p_type
== PT_NOTE
)
1385 elf_corefile_note (abfd
, i_phdrp
+ phindex
);
1389 /* Remember the entry point specified in the ELF file header. */
1391 bfd_get_start_address (abfd
) = i_ehdrp
->e_entry
;
1393 return (abfd
->xvec
);
1397 DEFUN (elf_mkobject
, (abfd
), bfd
*abfd
)
1399 /* this just does initialization */
1400 /* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
1401 elf_tdata(abfd
) = (struct elf_obj_tdata
*)
1402 bfd_zalloc (abfd
, sizeof(struct elf_obj_tdata
));
1403 if (elf_tdata(abfd
) == 0) {
1404 bfd_error
= no_memory
;
1407 /* since everything is done at close time, do we need any
1414 Create ELF output from BFD sections.
1416 Essentially, just create the section header and forget about the program
1421 /* lacking nested functions and nested types, set up for mapping over
1422 BFD sections to produce ELF sections */
1425 Elf_Internal_Ehdr
*i_ehdr
;
1426 Elf_Internal_Shdr
*i_shdrp
;
1427 struct strtab
*shstrtab
;
1434 DEFUN (elf_make_sections
, (abfd
, asect
, obj
),
1439 elf_sect_thunk
*thunk
= (elf_sect_thunk
*)obj
;
1440 /* most of what is in bfd_shdr_from_section goes in here... */
1441 /* and all of these sections generate at *least* one ELF section. */
1445 /* check if we're making a PROGBITS section... */
1446 /* if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD)) */
1447 /* this was too strict... what *do* we want to check here? */
1450 Elf_Internal_Shdr
*this_hdr
;
1451 this_section
= elf_section_from_bfd_section (abfd
, asect
);
1452 this_hdr
= &thunk
->i_shdrp
[this_section
];
1454 this_hdr
->sh_addr
= asect
->vma
;
1455 this_hdr
->sh_size
= asect
->_raw_size
;
1456 /* contents already set by elf_set_section_contents */
1458 if (asect
->flags
& SEC_RELOC
)
1460 /* emit a reloc section, and thus strtab and symtab... */
1461 Elf_Internal_Shdr
*rela_hdr
;
1462 Elf_Internal_Shdr
*symtab_hdr
;
1463 Elf_External_Rela
*outbound_relocs
;
1466 symtab_hdr
= &thunk
->i_shdrp
[thunk
->symtab_section
];
1468 if (thunk
->symtab_section
== this_section
+ 1)
1469 rela_section
= thunk
->symtab_section
+ 2; /* symtab + symstrtab */
1471 rela_section
= this_section
+ 1;
1472 rela_hdr
= &thunk
->i_shdrp
[rela_section
];
1473 rela_hdr
->sh_type
= SHT_RELA
;
1474 rela_hdr
->sh_link
= thunk
->symtab_section
;
1475 rela_hdr
->sh_info
= this_section
;
1476 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1477 /* orelocation has the data, reloc_count has the count... */
1478 rela_hdr
->sh_size
= rela_hdr
->sh_entsize
* asect
->reloc_count
;
1479 outbound_relocs
= (Elf_External_Rela
*)
1480 bfd_alloc(abfd
, asect
->reloc_count
* sizeof(Elf_External_Rela
));
1481 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
1483 Elf_Internal_Rela dst
;
1485 Elf_External_Rela
*src
;
1487 ptr
= asect
->orelocation
[idx
];
1488 src
= outbound_relocs
+ idx
;
1489 if (asect
->flags
& SEC_RELOC
)
1490 dst
.r_offset
= ptr
->address
- asect
->vma
;
1492 dst
.r_offset
= ptr
->address
;
1494 dst
.r_info
= ELF_R_INFO(1 /*ptr->sym_ptr_ptr*/, /* needs index into symtab (FIXME) */
1497 dst
.r_addend
= ptr
->addend
;
1498 elf_swap_reloca_out(abfd
, &dst
, src
);
1500 rela_hdr
->contents
= (void*)outbound_relocs
;
1506 DEFUN (elf_fake_sections
, (abfd
, asect
, obj
),
1511 elf_sect_thunk
*thunk
= (elf_sect_thunk
*)obj
;
1512 /* most of what is in bfd_shdr_from_section goes in here... */
1513 /* and all of these sections generate at *least* one ELF section. */
1516 /* check if we're making a PROGBITS section... */
1517 /* if ((asect->flags & SEC_ALLOC) && (asect->flags & SEC_LOAD)) */
1518 /* this was too strict... what *do* we want to check here? */
1521 Elf_Internal_Shdr
*this_hdr
;
1522 this_section
= thunk
->i_ehdr
->e_shnum
++;
1523 this_hdr
= &thunk
->i_shdrp
[this_section
];
1525 bfd_add_to_strtab (abfd
, thunk
->shstrtab
, asect
->name
);
1526 /* we need to log the type *now* so that elf_section_from_bfd_section
1527 can find us... have to set rawdata too. */
1528 this_hdr
->rawdata
= (void*)asect
;
1529 if ((asect
->flags
& SEC_ALLOC
) && (asect
->flags
& SEC_LOAD
))
1530 this_hdr
->sh_type
= SHT_PROGBITS
;
1532 /* what *do* we put here? */
1533 this_hdr
->sh_type
= SHT_PROGBITS
;
1536 if (asect
->flags
& SEC_RELOC
)
1538 /* emit a reloc section, and thus strtab and symtab... */
1539 Elf_Internal_Shdr
*rela_hdr
;
1540 Elf_Internal_Shdr
*symtab_hdr
;
1541 Elf_Internal_Shdr
*symstrtab_hdr
;
1543 int symstrtab_section
;
1545 /* note that only one symtab is used, so just remember it
1547 if (! thunk
->symtab_section
)
1549 thunk
->symtab_section
= thunk
->i_ehdr
->e_shnum
++;
1550 symtab_hdr
= &thunk
->i_shdrp
[thunk
->symtab_section
];
1551 symtab_hdr
->sh_name
=
1552 bfd_add_to_strtab (abfd
, thunk
->shstrtab
, ".symtab");
1553 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1554 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1556 symstrtab_section
= thunk
->i_ehdr
->e_shnum
++;
1557 BFD_ASSERT(symstrtab_section
== thunk
->symtab_section
+1);
1558 symstrtab_hdr
= &thunk
->i_shdrp
[symstrtab_section
];
1559 symtab_hdr
->sh_link
= symstrtab_section
;
1560 symstrtab_hdr
->sh_name
=
1561 bfd_add_to_strtab (abfd
, thunk
->shstrtab
, ".strtab");
1562 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
1564 symtab_hdr
->contents
= 0;
1565 symstrtab_hdr
->contents
= 0;
1566 symstrtab_hdr
->sh_size
= 0;
1569 symtab_hdr
= &thunk
->i_shdrp
[thunk
->symtab_section
];
1571 rela_section
= thunk
->i_ehdr
->e_shnum
++;
1572 rela_hdr
= &thunk
->i_shdrp
[rela_section
];
1574 bfd_add_2_to_strtab (abfd
, thunk
->shstrtab
, ".rela", asect
->name
);
1575 rela_hdr
->sh_type
= SHT_RELA
;
1576 rela_hdr
->sh_link
= thunk
->symtab_section
;
1577 rela_hdr
->sh_info
= this_section
;
1578 rela_hdr
->sh_entsize
= sizeof (Elf_External_Rela
);
1585 DEFUN (elf_compute_section_file_positions
, (abfd
), bfd
*abfd
)
1587 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1588 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
1589 struct strtab
*shstrtab
;
1590 int count
, maxsections
;
1593 if (! elf_shstrtab (abfd
)) {
1594 i_ehdrp
= elf_elfheader (abfd
); /* build new header in tdata memory */
1595 shstrtab
= bfd_new_strtab(abfd
);
1597 i_ehdrp
->e_ident
[EI_MAG0
] = ELFMAG0
;
1598 i_ehdrp
->e_ident
[EI_MAG1
] = ELFMAG1
;
1599 i_ehdrp
->e_ident
[EI_MAG2
] = ELFMAG2
;
1600 i_ehdrp
->e_ident
[EI_MAG3
] = ELFMAG3
;
1602 i_ehdrp
->e_ident
[EI_CLASS
] = ELFCLASS32
; /* FIXME: find out from bfd */
1603 i_ehdrp
->e_ident
[EI_DATA
] =
1604 abfd
->xvec
->byteorder_big_p
? ELFDATA2MSB
: ELFDATA2LSB
;
1605 i_ehdrp
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1607 for(count
= EI_PAD
; count
< EI_NIDENT
; count
++)
1608 i_ehdrp
->e_ident
[count
] = 0;
1610 i_ehdrp
->e_type
= (abfd
->flags
& EXEC_P
)? ET_EXEC
: ET_REL
;
1611 switch(bfd_get_arch(abfd
))
1613 case bfd_arch_unknown
:
1614 i_ehdrp
->e_machine
= EM_NONE
;
1616 case bfd_arch_sparc
:
1617 i_ehdrp
->e_machine
= EM_SPARC
;
1620 i_ehdrp
->e_machine
= EM_386
;
1623 i_ehdrp
->e_machine
= EM_68K
;
1626 i_ehdrp
->e_machine
= EM_88K
;
1629 i_ehdrp
->e_machine
= EM_860
;
1631 case bfd_arch_mips
: /* MIPS Rxxxx */
1632 i_ehdrp
->e_machine
= EM_MIPS
; /* only MIPS R3000 */
1634 /* also note that EM_M32, AT&T WE32100 is unknown to bfd */
1636 i_ehdrp
->e_machine
= EM_NONE
;
1638 i_ehdrp
->e_version
= EV_CURRENT
;
1639 i_ehdrp
->e_ehsize
= sizeof(Elf_External_Ehdr
);
1641 /* no program header, for now. */
1642 i_ehdrp
->e_phoff
= 0;
1643 i_ehdrp
->e_phentsize
= 0;
1644 i_ehdrp
->e_phnum
= 0;
1646 /* each bfd section is section header entry */
1647 i_ehdrp
->e_entry
= bfd_get_start_address (abfd
);
1648 i_ehdrp
->e_shentsize
= sizeof (Elf_External_Shdr
);
1650 /* figure at most each section can have a rel, strtab, symtab */
1651 maxsections
= 4*bfd_count_sections(abfd
)+2;
1653 i_ehdrp
->e_shoff
= i_ehdrp
->e_ehsize
;
1655 /* and we'll just have to fix up the offsets later. */
1656 /* outbase += i_ehdr.e_shentsize * i_ehdr.e_shnum; */
1658 i_shdrp
= (Elf_Internal_Shdr
*)
1659 bfd_alloc (abfd
, sizeof (*i_shdrp
) * maxsections
);
1662 bfd_error
= no_memory
;
1665 for (count
=0; count
< maxsections
; count
++)
1667 i_shdrp
[count
].rawdata
= 0;
1668 i_shdrp
[count
].contents
= 0;
1672 i_shdrp
[0].sh_name
= 0;
1673 i_shdrp
[0].sh_type
= SHT_NULL
;
1674 i_shdrp
[0].sh_flags
= 0;
1675 i_shdrp
[0].sh_addr
= 0;
1676 i_shdrp
[0].sh_offset
= 0;
1677 i_shdrp
[0].sh_size
= 0;
1678 i_shdrp
[0].sh_link
= SHN_UNDEF
;
1679 i_shdrp
[0].sh_info
= 0;
1680 i_shdrp
[0].sh_addralign
= 0;
1681 i_shdrp
[0].sh_entsize
= 0;
1683 i_ehdrp
->e_shnum
= 1;
1685 elf_elfsections (abfd
) = i_shdrp
;
1686 elf_shstrtab (abfd
) = shstrtab
;
1688 est
.i_ehdr
= elf_elfheader(abfd
);
1689 est
.i_shdrp
= elf_elfsections(abfd
);
1690 est
.shstrtab
= elf_shstrtab(abfd
);
1691 est
.symtab_section
= 0; /* elf_fake_sections fils it in */
1693 bfd_map_over_sections(abfd
, elf_fake_sections
, &est
);
1694 elf_onesymtab (abfd
) = est
.symtab_section
;
1699 DEFUN (elf_write_object_contents
, (abfd
), bfd
*abfd
)
1701 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
1702 Elf_Internal_Ehdr
*i_ehdrp
; /* Elf file header, internal form */
1703 Elf_External_Shdr
*x_shdrp
; /* Section header table, external form */
1704 Elf_Internal_Shdr
*i_shdrp
; /* Section header table, internal form */
1710 struct strtab
*shstrtab
;
1712 if(abfd
->output_has_begun
== false)
1713 elf_compute_section_file_positions(abfd
);
1715 i_ehdrp
= elf_elfheader (abfd
);
1716 i_shdrp
= elf_elfsections (abfd
);
1717 shstrtab
= elf_shstrtab (abfd
);
1719 est
.i_ehdr
= i_ehdrp
;
1720 est
.i_shdrp
= i_shdrp
;
1721 est
.shstrtab
= shstrtab
;
1722 est
.symtab_section
= elf_onesymtab (abfd
); /* filled in by elf_fake */
1724 bfd_map_over_sections(abfd
, elf_make_sections
, &est
);
1726 /* dump out the one symtab */
1728 int symcount
= bfd_get_symcount (abfd
);
1729 asymbol
** syms
= bfd_get_outsymbols (abfd
);
1730 struct strtab
* stt
= bfd_new_strtab (abfd
);
1731 Elf_Internal_Shdr
*symtab_hdr
;
1732 Elf_Internal_Shdr
*symstrtab_hdr
;
1733 int symstrtab_section
;
1734 Elf_External_Sym
*outbound_syms
;
1737 symtab_hdr
= &i_shdrp
[est
.symtab_section
];
1738 symtab_hdr
->sh_type
= SHT_SYMTAB
;
1739 symtab_hdr
->sh_entsize
= sizeof (Elf_External_Sym
);
1740 symtab_hdr
->sh_size
= symtab_hdr
->sh_entsize
* symcount
;
1742 /* see assert in elf_fake_sections that supports this: */
1743 symstrtab_section
= est
.symtab_section
+1;
1744 symstrtab_hdr
= &i_shdrp
[symstrtab_section
];
1745 symtab_hdr
->sh_link
= symstrtab_section
;
1746 symstrtab_hdr
->sh_type
= SHT_STRTAB
;
1748 outbound_syms
= (Elf_External_Sym
*)
1749 bfd_alloc(abfd
, (1+symcount
) * sizeof(Elf_External_Sym
));
1750 /* now generate the data (for "contents") */
1751 for (idx
= 0; idx
< symcount
; idx
++)
1753 Elf_Internal_Sym sym
;
1754 sym
.st_name
= bfd_add_to_strtab (abfd
, stt
, syms
[idx
]->name
);
1755 sym
.st_value
= syms
[idx
]->value
;
1756 sym
.st_size
= 0; /* we should recover this (FIXME) */
1757 if (syms
[idx
]->flags
& BSF_WEAK
)
1758 sym
.st_info
= ELF_ST_INFO(STB_WEAK
, STT_OBJECT
);
1759 else if (syms
[idx
]->flags
& BSF_LOCAL
)
1760 sym
.st_info
= ELF_ST_INFO(STB_LOCAL
, STT_OBJECT
);
1761 else if (syms
[idx
]->flags
& BSF_GLOBAL
)
1762 sym
.st_info
= ELF_ST_INFO(STB_GLOBAL
, STT_OBJECT
);
1763 else if (syms
[idx
]->flags
& BSF_SECTION_SYM
)
1764 sym
.st_info
= ELF_ST_INFO(STB_LOCAL
, STT_SECTION
);
1765 else if (syms
[idx
]->flags
& BSF_FILE
)
1766 sym
.st_info
= ELF_ST_INFO(STB_LOCAL
, STT_FILE
);
1769 if (syms
[idx
]->section
)
1771 elf_section_from_bfd_section(abfd
,
1772 syms
[idx
]->section
->output_section
);
1774 sym
.st_shndx
= SHN_UNDEF
;
1776 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
+idx
+1);
1779 /* fill in 0th symbol */
1780 Elf_Internal_Sym sym
;
1786 sym
.st_shndx
= SHN_UNDEF
;
1787 elf_swap_symbol_out (abfd
, &sym
, outbound_syms
);
1789 symtab_hdr
->contents
= (void*)outbound_syms
;
1790 symstrtab_hdr
->contents
= (void*)stt
->tab
;
1791 symstrtab_hdr
->sh_size
= stt
->length
;
1794 /* put the strtab out too... */
1796 Elf_Internal_Shdr
*this_hdr
;
1799 this_section
= i_ehdrp
->e_shnum
++;
1800 i_ehdrp
->e_shstrndx
= this_section
;
1801 this_hdr
= &i_shdrp
[this_section
];
1802 this_hdr
->sh_name
= bfd_add_to_strtab (abfd
, shstrtab
, ".shstrtab");
1803 this_hdr
->sh_size
= shstrtab
->length
;
1804 this_hdr
->contents
= (void*)shstrtab
->tab
;
1807 outbase
= i_ehdrp
->e_ehsize
;
1809 /* swap the header before spitting it out... */
1810 elf_swap_ehdr_out (abfd
, i_ehdrp
, &x_ehdr
);
1811 bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
);
1812 bfd_write ((PTR
) &x_ehdr
, sizeof(x_ehdr
), 1, abfd
);
1814 outbase
+= i_ehdrp
->e_shentsize
* i_ehdrp
->e_shnum
;
1816 /* now we fix up the offsets... */
1817 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
1819 i_shdrp
[count
].sh_offset
= outbase
;
1820 outbase
+= i_shdrp
[count
].sh_size
;
1823 /* at this point we've concocted all the ELF sections... */
1824 x_shdrp
= (Elf_External_Shdr
*)
1825 bfd_alloc (abfd
, sizeof (*x_shdrp
) * (i_ehdrp
->e_shnum
));
1828 bfd_error
= no_memory
;
1832 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
1834 elf_swap_shdr_out (abfd
, i_shdrp
+count
, x_shdrp
+count
);
1836 bfd_write ((PTR
) x_shdrp
, sizeof(*x_shdrp
), i_ehdrp
->e_shnum
, abfd
);
1837 /* need to dump the string table too... */
1839 /* after writing the headers, we need to write the sections too... */
1840 nsect
= abfd
->sections
;
1841 for (count
= 0; count
< i_ehdrp
->e_shnum
; count
++)
1843 if(i_shdrp
[count
].contents
)
1845 bfd_seek (abfd
, i_shdrp
[count
].sh_offset
, SEEK_SET
);
1846 bfd_write (i_shdrp
[count
].contents
, i_shdrp
[count
].sh_size
, 1, abfd
);
1850 /* sample use of bfd:
1851 * bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
1852 * bfd_write ((PTR) &exec_bytes, 1, EXEC_BYTES_SIZE, abfd);
1853 * if (bfd_seek(abfd, scn_base, SEEK_SET) != 0)
1855 * old = bfd_tell(abfd);
1862 /* Given an index of a section, retrieve a pointer to it. Note
1863 that for our purposes, sections are indexed by {1, 2, ...} with
1864 0 being an illegal index. */
1866 /* In the original, each ELF section went into exactly one BFD
1867 section. This doesn't really make sense, so we need a real mapping.
1868 The mapping has to hide in the Elf_Internal_Shdr since asection
1869 doesn't have anything like a tdata field... */
1872 DEFUN (section_from_elf_index
, (abfd
, index
),
1876 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
1877 Elf_Internal_Shdr
*hdr
= i_shdrp
+ index
;
1879 switch (hdr
->sh_type
)
1881 /* ELF sections that map to BFD sections */
1885 bfd_section_from_shdr (abfd
, index
);
1886 return (struct sec
*)hdr
->rawdata
;
1889 return (struct sec
*)&bfd_abs_section
;
1893 /* given a section, search the header to find them... */
1895 DEFUN (elf_section_from_bfd_section
, (abfd
, asect
),
1899 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
1901 Elf_Internal_Shdr
*hdr
;
1902 int maxindex
= elf_elfheader (abfd
)->e_shnum
;
1904 for(index
= 0; index
< maxindex
; index
++) {
1905 hdr
= &i_shdrp
[index
];
1906 switch (hdr
->sh_type
)
1908 /* ELF sections that map to BFD sections */
1913 if (((struct sec
*)(hdr
->rawdata
)) == asect
)
1925 DEFUN (elf_slurp_symbol_table
, (abfd
, symptrs
),
1927 asymbol
**symptrs
) /* Buffer for generated bfd symbols */
1929 Elf_Internal_Shdr
*i_shdrp
= elf_elfsections (abfd
);
1930 Elf_Internal_Shdr
*hdr
= i_shdrp
+ elf_onesymtab (abfd
);
1931 int symcount
; /* Number of external ELF symbols */
1933 asymbol
*sym
; /* Pointer to current bfd symbol */
1934 asymbol
*symbase
; /* Buffer for generated bfd symbols */
1935 Elf_Internal_Sym i_sym
;
1936 Elf_External_Sym
*x_symp
;
1938 /* this is only valid because there is only one symtab... */
1939 /* FIXME: This is incorrect, there may also be a dynamic symbol
1940 table which is a subset of the full symbol table. We either need
1941 to be prepared to read both (and merge them) or ensure that we
1942 only read the full symbol table. Currently we only get called to
1943 read the full symbol table. -fnf */
1944 if (bfd_get_outsymbols (abfd
) != NULL
)
1949 /* Read each raw ELF symbol, converting from external ELF form to
1950 internal ELF form, and then using the information to create a
1951 canonical bfd symbol table entry.
1953 Note that we allocate the initial bfd canonical symbol buffer
1954 based on a one-to-one mapping of the ELF symbols to canonical
1955 symbols. We actually use all the ELF symbols, so there will be no
1956 space left over at the end. When we have all the symbols, we
1957 build the caller's pointer vector. */
1959 if (bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
) == -1)
1961 bfd_error
= system_call_error
;
1965 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
1966 symbase
= (asymbol
*) bfd_zalloc (abfd
, symcount
* sizeof (asymbol
));
1969 /* Temporarily allocate room for the raw ELF symbols. */
1970 x_symp
= (Elf_External_Sym
*) bfd_xmalloc (symcount
* sizeof (Elf_External_Sym
));
1972 if (bfd_read ((PTR
) x_symp
, sizeof (Elf_External_Sym
), symcount
, abfd
)
1973 != symcount
* sizeof (Elf_External_Sym
))
1976 bfd_error
= system_call_error
;
1979 /* Skip first symbol, which is a null dummy. */
1980 for (i
= 1; i
< symcount
; i
++)
1982 elf_swap_symbol_in (abfd
, x_symp
+ i
, &i_sym
);
1983 sym
-> the_bfd
= abfd
;
1984 if (i_sym
.st_name
> 0)
1985 sym
-> name
= elf_string_from_elf_section(abfd
, hdr
->sh_link
,
1988 sym
-> name
= "unnamed"; /* perhaps should include the number? */
1989 sym
-> value
= i_sym
.st_value
;
1990 /* FIXME -- this is almost certainly bogus. It's from Pace Willisson's
1991 hasty Solaris support, to pass the sizes of object files or functions
1992 down into GDB via the back door, to circumvent some other kludge in
1993 how Sun hacked stabs. -- gnu@cygnus.com */
1994 sym
-> udata
= (PTR
)i_sym
.st_size
;
1995 /* FIXME -- end of bogosity. */
1996 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
1998 sym
-> section
= section_from_elf_index (abfd
, i_sym
.st_shndx
);
2000 else if (i_sym
.st_shndx
== SHN_ABS
)
2002 sym
-> section
= &bfd_abs_section
;
2004 else if (i_sym
.st_shndx
== SHN_COMMON
)
2006 sym
-> section
= &bfd_com_section
;
2008 else if (i_sym
.st_shndx
== SHN_UNDEF
)
2010 sym
-> section
= &bfd_und_section
;
2013 sym
-> section
= &bfd_abs_section
;
2015 switch (ELF_ST_BIND (i_sym
.st_info
))
2018 sym
-> flags
|= BSF_LOCAL
;
2021 sym
-> flags
|= (BSF_GLOBAL
| BSF_EXPORT
);
2024 sym
-> flags
|= BSF_WEAK
;
2028 switch (ELF_ST_TYPE (i_sym
.st_info
))
2031 sym
->flags
|= BSF_SECTION_SYM
| BSF_DEBUGGING
;
2034 sym
->flags
|= BSF_FILE
| BSF_DEBUGGING
;
2040 /* We rely on the zalloc to clear out the final symbol entry. */
2042 /* We're now done with the raw symbols. */
2045 bfd_get_symcount(abfd
) = symcount
= sym
- symbase
;
2047 /* Fill in the user's symbol pointer vector if needed. */
2051 while (symcount
-- > 0)
2055 *symptrs
= 0; /* Final null pointer */
2061 /* Return the number of bytes required to hold the symtab vector.
2063 Note that we base it on the count plus 1, since we will null terminate
2064 the vector allocated based on this size. However, the ELF symbol table
2065 always has a dummy entry as symbol #0, so it ends up even. */
2068 DEFUN (elf_get_symtab_upper_bound
, (abfd
), bfd
*abfd
)
2070 unsigned int symcount
;
2071 unsigned int symtab_size
= 0;
2072 Elf_Internal_Shdr
*i_shdrp
;
2073 Elf_Internal_Shdr
*hdr
;
2075 i_shdrp
= elf_elfsections (abfd
);
2076 if (i_shdrp
!= NULL
)
2078 hdr
= i_shdrp
+ elf_onesymtab (abfd
);
2079 symcount
= hdr
->sh_size
/ sizeof (Elf_External_Sym
);
2080 symtab_size
= (symcount
- 1 + 1) * (sizeof (asymbol
));
2082 return (symtab_size
);
2086 This function return the number of bytes required to store the
2087 relocation information associated with section <<sect>>
2088 attached to bfd <<abfd>>
2092 elf_get_reloc_upper_bound (abfd
, asect
)
2096 if (asect
->flags
& SEC_RELOC
)
2098 /* either rel or rela */
2099 return asect
->_raw_size
;
2109 R_SPARC_8
, R_SPARC_16
, R_SPARC_32
,
2110 R_SPARC_DISP8
, R_SPARC_DISP16
, R_SPARC_DISP32
,
2111 R_SPARC_WDISP30
, R_SPARC_WDISP22
,
2112 R_SPARC_HI22
, R_SPARC_22
,
2113 R_SPARC_13
, R_SPARC_LO10
,
2114 R_SPARC_GOT10
, R_SPARC_GOT13
, R_SPARC_GOT22
,
2115 R_SPARC_PC10
, R_SPARC_PC22
,
2118 R_SPARC_GLOB_DAT
, R_SPARC_JMP_SLOT
,
2123 R_386_offset
= R_SPARC_max
,
2125 R_386_32
, R_386_PC32
,
2126 R_386_GOT32
, R_386_PLT32
,
2128 R_386_GLOB_DAT
, R_386_JUMP_SLOT
,
2130 R_386_GOTOFF
, R_386_GOTPC
,
2134 #if 0 /* not used */
2135 #define RELOC_TYPE_NAMES \
2137 "R_SPARC_8", "R_SPARC_16", "R_SPARC_32", \
2138 "R_SPARC_DISP8", "R_SPARC_DISP16", "R_SPARC_DISP32", \
2139 "R_SPARC_WDISP30", "R_SPARC_WDISP22", \
2140 "R_SPARC_HI22", "R_SPARC_22", \
2141 "R_SPARC_13", "R_SPARC_LO10", \
2142 "R_SPARC_GOT10", "R_SPARC_GOT13", "R_SPARC_GOT22", \
2143 "R_SPARC_PC10", "R_SPARC_PC22", \
2146 "R_SPARC_GLOB_DAT", "R_SPARC_JMP_SLOT", \
2147 "R_SPARC_RELATIVE", \
2150 "R_386_32", "R_386_PC32", \
2151 "R_386_GOT32", "R_386_PLT32", \
2153 "R_386_GLOB_DAT", "R_386_JUMP_SLOT", \
2155 "R_386_GOTOFF", "R_386_GOTPC"
2158 static reloc_howto_type elf_sparc_howto_table
[] =
2160 HOWTO(R_SPARC_NONE
, 0,0, 0,false,0,false,false, 0,"R_SPARC_NONE", false,0,0x00000000,false),
2161 HOWTO(R_SPARC_8
, 0,0, 8,false,0,true, true, 0,"R_SPARC_8", false,0,0x000000ff,false),
2162 HOWTO(R_SPARC_16
, 0,1,16,false,0,true, true, 0,"R_SPARC_16", false,0,0x0000ffff,false),
2163 HOWTO(R_SPARC_32
, 0,2,32,false,0,true, true, 0,"R_SPARC_32", false,0,0xffffffff,false),
2164 HOWTO(R_SPARC_DISP8
, 0,0, 8,true, 0,false, true, 0,"R_SPARC_DISP8", false,0,0x000000ff,false),
2165 HOWTO(R_SPARC_DISP16
, 0,1,16,true, 0,false, true, 0,"R_SPARC_DISP16", false,0,0x0000ffff,false),
2166 HOWTO(R_SPARC_DISP32
, 0,2,32,true, 0,false, true, 0,"R_SPARC_DISP32", false,0,0x00ffffff,false),
2167 HOWTO(R_SPARC_WDISP30
,2,2,30,true, 0,false, true, 0,"R_SPARC_WDISP30",false,0,0x3fffffff,false),
2168 HOWTO(R_SPARC_WDISP22
,2,2,22,true, 0,false, true, 0,"R_SPARC_WDISP22",false,0,0x003fffff,false),
2169 HOWTO(R_SPARC_HI22
, 10,2,22,false,0,true, false, 0,"R_SPARC_HI22", false,0,0x003fffff,false),
2170 HOWTO(R_SPARC_22
, 0,2,22,false,0,true, true, 0,"R_SPARC_22", false,0,0x003fffff,false),
2171 HOWTO(R_SPARC_13
, 0,1,13,false,0,true, true, 0,"R_SPARC_13", false,0,0x00001fff,false),
2172 HOWTO(R_SPARC_LO10
, 0,1,10,false,0,true, false, 0,"R_SPARC_LO10", false,0,0x000003ff,false),
2173 HOWTO(R_SPARC_GOT10
, 0,1,10,false,0,false, true, 0,"R_SPARC_GOT10", false,0,0x000003ff,false),
2174 HOWTO(R_SPARC_GOT13
, 0,1,13,false,0,false, true, 0,"R_SPARC_GOT13", false,0,0x00001fff,false),
2175 HOWTO(R_SPARC_GOT22
, 10,2,22,false,0,false, true, 0,"R_SPARC_GOT22", false,0,0x003fffff,false),
2176 HOWTO(R_SPARC_PC10
, 0,1,10,false,0,true, true, 0,"R_SPARC_PC10", false,0,0x000003ff,false),
2177 HOWTO(R_SPARC_PC22
, 0,2,22,false,0,true, true, 0,"R_SPARC_PC22", false,0,0x003fffff,false),
2178 HOWTO(R_SPARC_WPLT30
, 0,0,00,false,0,false,false, 0,"R_SPARC_WPLT30", false,0,0x00000000,false),
2179 HOWTO(R_SPARC_COPY
, 0,0,00,false,0,false,false, 0,"R_SPARC_COPY", false,0,0x00000000,false),
2180 HOWTO(R_SPARC_GLOB_DAT
,0,0,00,false,0,false,false,0,"R_SPARC_GLOB_DAT",false,0,0x00000000,false),
2181 HOWTO(R_SPARC_JMP_SLOT
,0,0,00,false,0,false,false,0,"R_SPARC_JMP_SLOT",false,0,0x00000000,false),
2182 HOWTO(R_SPARC_RELATIVE
,0,0,00,false,0,false,false,0,"R_SPARC_RELATIVE",false,0,0x00000000,false),
2183 HOWTO(R_SPARC_UA32
, 0,0,00,false,0,false,false,0,"R_SPARC_UA32", false,0,0x00000000,false),
2187 static const reloc_howto_type elf_386_howto_table
[] =
2189 HOWTO (R_386_NONE
, 0, 0, 0, false, 0,
2193 DEFUN(elf_info_to_howto
, (abfd
, cache_ptr
, dst
),
2195 arelent
*cache_ptr AND
2196 Elf_Internal_Rela
*dst
)
2198 /* FIXME!!! just doing sparc for now... */
2199 switch (abfd
->arch_info
->arch
)
2201 case bfd_arch_sparc
:
2202 BFD_ASSERT (ELF_R_TYPE(dst
->r_info
) < (unsigned char) R_SPARC_max
);
2203 cache_ptr
->howto
= &elf_sparc_howto_table
[ELF_R_TYPE(dst
->r_info
)];
2208 BFD_ASSER (ELF_R_TYPE (dst
->r_info
) < R_386_max
);
2209 cache_ptr
->howto
= &elf_i386_howto_table
[ELF_R_TYPE (dst
->r_info
)];
2214 fprintf (stderr
, "elf_info_to_howto not implemented\n");
2220 DEFUN(elf_slurp_reloca_table
,(abfd
, asect
, symbols
),
2225 Elf_External_Rela
*native_relocs
;
2226 arelent
*reloc_cache
;
2231 if (asect
->relocation
)
2233 if (asect
->reloc_count
== 0)
2235 if (asect
->flags
& SEC_CONSTRUCTOR
)
2238 bfd_seek (abfd
, asect
->rel_filepos
, SEEK_SET
);
2239 native_relocs
= (Elf_External_Rela
*)
2240 bfd_alloc(abfd
, asect
->reloc_count
* sizeof(Elf_External_Rela
));
2241 bfd_read ((PTR
) native_relocs
,
2242 sizeof(Elf_External_Rela
), asect
->reloc_count
, abfd
);
2244 reloc_cache
= (arelent
*)
2245 bfd_alloc(abfd
, (size_t) (asect
->reloc_count
* sizeof(arelent
)));
2247 if (! reloc_cache
) {
2248 bfd_error
= no_memory
;
2252 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
2254 #ifdef RELOC_PROCESSING
2255 /* sparc, 68k, 88k, 860 use rela only. */
2256 /* 386 and we32000 use rel only... fix it for them later. */
2257 Elf_Internal_Rela dst
;
2258 Elf_External_Rela
*src
;
2260 cache_ptr
= reloc_cache
+ idx
;
2261 src
= native_relocs
+ idx
;
2262 elf_swap_reloca_in(abfd
, src
, &dst
);
2264 RELOC_PROCESSING(cache_ptr
, &dst
, symbols
, abfd
, asect
);
2266 Elf_Internal_Rela dst
;
2267 Elf_External_Rela
*src
;
2269 cache_ptr
= reloc_cache
+ idx
;
2270 src
= native_relocs
+ idx
;
2272 elf_swap_reloca_in(abfd
, src
, &dst
);
2274 if(asect
->flags
& SEC_RELOC
)
2276 /* relocatable, so the offset is off of the section */
2277 cache_ptr
->address
= dst
.r_offset
+ asect
->vma
;
2281 /* non-relocatable, so the offset a virtual address */
2282 cache_ptr
->address
= dst
.r_offset
;
2284 /* ELF_R_SYM(dst.r_info) is the symbol table offset... */
2285 cache_ptr
->sym_ptr_ptr
= symbols
+ ELF_R_SYM(dst
.r_info
);
2286 cache_ptr
->addend
= dst
.r_addend
;
2288 /* Fill in the cache_ptr->howto field from dst.r_type */
2289 elf_info_to_howto(abfd
, cache_ptr
, &dst
);
2293 asect
->relocation
= reloc_cache
;
2299 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
2305 arelent
*tblptr
= section
->relocation
;
2306 unsigned int count
= 0;
2308 /* snarfed from coffcode.h */
2309 /* FIXME: this could be reloc... */
2310 elf_slurp_reloca_table(abfd
, section
, symbols
);
2312 tblptr
= section
->relocation
;
2316 for (; count
++ < section
->reloc_count
;)
2317 *relptr
++ = tblptr
++;
2320 return section
->reloc_count
;
2324 DEFUN (elf_get_symtab
, (abfd
, alocation
),
2326 asymbol
**alocation
)
2329 if (!elf_slurp_symbol_table (abfd
, alocation
))
2332 return (bfd_get_symcount (abfd
));
2336 DEFUN (elf_make_empty_symbol
, (abfd
),
2339 elf_symbol_type
*newsym
;
2341 newsym
= (elf_symbol_type
*) bfd_zalloc (abfd
, sizeof (elf_symbol_type
));
2344 bfd_error
= no_memory
;
2349 newsym
-> symbol
.the_bfd
= abfd
;
2350 return (&newsym
-> symbol
);
2355 DEFUN (elf_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
2356 bfd
*ignore_abfd AND
2359 bfd_print_symbol_type how
)
2361 FILE *file
= (FILE *)filep
;
2364 case bfd_print_symbol_name
:
2365 fprintf(file
, "%s", symbol
->name
);
2367 case bfd_print_symbol_more
:
2368 fprintf(file
, "elf %lx %lx",
2372 case bfd_print_symbol_nm
:
2373 case bfd_print_symbol_all
:
2375 CONST
char *section_name
;
2376 section_name
= symbol
->section
? symbol
->section
->name
: "(*none*)";
2377 bfd_print_symbol_vandf((PTR
) file
, symbol
);
2378 fprintf(file
, " %s\t%s",
2388 DEFUN (elf_get_lineno
,(ignore_abfd
, symbol
),
2389 bfd
*ignore_abfd AND
2392 fprintf (stderr
, "elf_get_lineno unimplemented\n");
2399 DEFUN (elf_set_arch_mach
,(abfd
, arch
, machine
),
2401 enum bfd_architecture arch AND
2402 unsigned long machine
)
2404 /* Allow any architecture to be supported by the elf backend */
2407 case bfd_arch_unknown
: /* EM_NONE */
2408 case bfd_arch_sparc
: /* EM_SPARC */
2409 case bfd_arch_i386
: /* EM_386 */
2410 case bfd_arch_m68k
: /* EM_68K */
2411 case bfd_arch_m88k
: /* EM_88K */
2412 case bfd_arch_i860
: /* EM_860 */
2413 case bfd_arch_mips
: /* EM_MIPS (MIPS R3000) */
2414 return bfd_default_set_arch_mach(abfd
, arch
, machine
);
2421 DEFUN (elf_find_nearest_line
,(abfd
,
2429 asection
*section AND
2430 asymbol
**symbols AND
2432 CONST
char **filename_ptr AND
2433 CONST
char **functionname_ptr AND
2434 unsigned int *line_ptr
)
2436 fprintf (stderr
, "elf_find_nearest_line unimplemented\n");
2443 DEFUN (elf_sizeof_headers
, (abfd
, reloc
),
2447 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
2454 DEFUN(elf_set_section_contents
, (abfd
, section
, location
, offset
, count
),
2459 bfd_size_type count
)
2463 if (abfd
->output_has_begun
== false) /* set by bfd.c handler? */
2465 /* do setup calculations (FIXME) */
2466 elf_compute_section_file_positions(abfd
);
2469 if(bfd_seek (abfd
, (file_ptr
)section
->filepos
+ offset
, SEEK_SET
) == -1)
2471 if(bfd_write (location
, (bfd_size_type
)1, count
, abfd
) != count
)
2474 /* we really just need to save the contents away... */
2475 dest_sect
= elf_section_from_bfd_section(abfd
, section
);
2479 /* FIXME: allocate in set_section_size, then copy in here... */
2480 contents
= (void*)bfd_alloc(abfd
, count
);
2481 BFD_ASSERT(contents
);
2482 memcpy(contents
, location
, count
);
2483 elf_elfsections (abfd
)[dest_sect
].contents
= contents
;
2489 /* This structure contains everything that BFD knows about a target.
2490 It includes things like its byte order, name, what routines to call
2491 to do various operations, etc. Every BFD points to a target structure
2492 with its "xvec" member.
2494 There are two such structures here: one for big-endian machines and
2495 one for little-endian machines. */
2497 /* Archives are generic or unimplemented. */
2498 #define elf_slurp_armap bfd_slurp_coff_armap
2499 #define elf_slurp_extended_name_table _bfd_slurp_extended_name_table
2500 #define elf_truncate_arname bfd_dont_truncate_arname
2501 #define elf_openr_next_archived_file bfd_generic_openr_next_archived_file
2502 #define elf_generic_stat_arch_elt bfd_generic_stat_arch_elt
2503 #define elf_write_armap coff_write_armap
2505 /* Ordinary section reading and writing */
2506 #define elf_new_section_hook _bfd_dummy_new_section_hook
2507 #define elf_get_section_contents bfd_generic_get_section_contents
2508 /* #define elf_set_section_contents bfd_generic_set_section_contents */
2509 #define elf_close_and_cleanup bfd_generic_close_and_cleanup
2511 #define elf_bfd_debug_info_start bfd_void
2512 #define elf_bfd_debug_info_end bfd_void
2513 #define elf_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
2514 #define elf_bfd_get_relocated_section_contents \
2515 bfd_generic_get_relocated_section_contents
2516 #define elf_bfd_relax_section bfd_generic_relax_section
2517 #define elf_bfd_seclet_link bfd_generic_seclet_link
2518 #define elf_bfd_reloc_type_lookup \
2519 ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
2520 #define elf_bfd_make_debug_symbol \
2521 ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
2523 bfd_target elf_big_vec
=
2525 /* name: identify kind of target */
2528 /* flavour: general indication about file */
2529 bfd_target_elf_flavour
,
2531 /* byteorder_big_p: data is big endian */
2534 /* header_byteorder_big_p: header is also big endian */
2537 /* object_flags: mask of all file flags */
2538 (HAS_RELOC
| EXEC_P
| HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
|
2541 /* section_flags: mask of all section flags */
2542 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
|
2543 SEC_CODE
| SEC_DATA
),
2545 /* leading_symbol_char: is the first char of a user symbol
2546 predictable, and if so what is it */
2549 /* ar_pad_char: pad character for filenames within an archive header
2550 FIXME: this really has nothing to do with ELF, this is a characteristic
2551 of the archiver and/or os and should be independently tunable */
2554 /* ar_max_namelen: maximum number of characters in an archive header
2555 FIXME: this really has nothing to do with ELF, this is a characteristic
2556 of the archiver and should be independently tunable. This value is
2557 a WAG (wild a** guess) */
2560 /* align_power_min: minimum alignment restriction for any section
2561 FIXME: this value may be target machine dependent */
2564 /* Routines to byte-swap various sized integers from the data sections */
2565 _do_getb64
, _do_putb64
, _do_getb32
, _do_putb32
, _do_getb16
, _do_putb16
,
2567 /* Routines to byte-swap various sized integers from the file headers */
2568 _do_getb64
, _do_putb64
, _do_getb32
, _do_putb32
, _do_getb16
, _do_putb16
,
2570 /* bfd_check_format: check the format of a file being read */
2571 { _bfd_dummy_target
, /* unknown format */
2572 elf_object_p
, /* assembler/linker output (object file) */
2573 bfd_generic_archive_p
, /* an archive */
2574 elf_core_file_p
/* a core file */
2577 /* bfd_set_format: set the format of a file being written */
2580 _bfd_generic_mkarchive
,
2584 /* bfd_write_contents: write cached information into a file being written */
2586 elf_write_object_contents
,
2587 _bfd_write_archive_contents
,
2591 /* Initialize a jump table with the standard macro. All names start with
2599 bfd_target elf_little_vec
=
2601 /* name: identify kind of target */
2604 /* flavour: general indication about file */
2605 bfd_target_elf_flavour
,
2607 /* byteorder_big_p: data is big endian */
2608 false, /* Nope -- this one's little endian */
2610 /* header_byteorder_big_p: header is also big endian */
2611 false, /* Nope -- this one's little endian */
2613 /* object_flags: mask of all file flags */
2614 (HAS_RELOC
| EXEC_P
| HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
|
2617 /* section_flags: mask of all section flags */
2618 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
|
2621 /* leading_symbol_char: is the first char of a user symbol
2622 predictable, and if so what is it */
2625 /* ar_pad_char: pad character for filenames within an archive header
2626 FIXME: this really has nothing to do with ELF, this is a characteristic
2627 of the archiver and/or os and should be independently tunable */
2630 /* ar_max_namelen: maximum number of characters in an archive header
2631 FIXME: this really has nothing to do with ELF, this is a characteristic
2632 of the archiver and should be independently tunable. This value is
2633 a WAG (wild a** guess) */
2636 /* align_power_min: minimum alignment restriction for any section
2637 FIXME: this value may be target machine dependent */
2640 /* Routines to byte-swap various sized integers from the data sections */
2641 _do_getl64
, _do_putl64
, _do_getl32
, _do_putl32
, _do_getl16
, _do_putl16
,
2643 /* Routines to byte-swap various sized integers from the file headers */
2644 _do_getl64
, _do_putl64
, _do_getl32
, _do_putl32
, _do_getl16
, _do_putl16
,
2646 /* bfd_check_format: check the format of a file being read */
2647 { _bfd_dummy_target
, /* unknown format */
2648 elf_object_p
, /* assembler/linker output (object file) */
2649 bfd_generic_archive_p
, /* an archive */
2650 elf_core_file_p
/* a core file */
2653 /* bfd_set_format: set the format of a file being written */
2656 _bfd_generic_mkarchive
,
2660 /* bfd_write_contents: write cached information into a file being written */
2662 elf_write_object_contents
,
2663 _bfd_write_archive_contents
,
2667 /* Initialize a jump table with the standard macro. All names start with