1 /* ELF support for BFD.
2 Copyright (C) 1991 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".
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
25 /****************************************
29 This is only a partial ELF implementation,
30 incorporating only those parts that are
31 required to get gdb up and running. It is
32 expected that it will be expanded to a full
33 ELF implementation at some future date.
35 Unimplemented stubs call abort() to ensure
36 that they get proper attention if they are
37 ever called. The stubs are here since
38 this version was hacked from the COFF
39 version, and thus they will probably
40 go away or get expanded appropriately in a
45 *****************************************/
48 /* Problems and other issues to resolve.
50 (1) BFD expects there to be some fixed number of "sections" in
51 the object file. I.E. there is a "section_count" variable in the
52 bfd structure which contains the number of sections. However, ELF
53 supports multiple "views" of a file. In particular, with current
54 implementations, executable files typically have two tables, a
55 program header table and a section header table, both of which
56 partition the executable.
58 In ELF-speak, the "linking view" of the file uses the section header
59 table to access "sections" within the file, and the "execution view"
60 uses the program header table to access "segments" within the file.
61 "Segments" typically may contain all the data from one or more
64 Note that the section header table is optional in ELF executables,
65 but it is this information that is most useful to gdb. If the
66 section header table is missing, then gdb should probably try
67 to make do with the program header table. (FIXME)
75 #include "elf-common.h"
76 #include "elf-internal.h"
77 #include "elf-external.h"
79 #ifdef HAVE_PROCFS /* Some core file support requires host /proc files */
80 #include <sys/procfs.h>
82 #define bfd_prstatus(abfd, descdata, descsz, filepos) /* Define away */
83 #define bfd_fpregset(abfd, descdata, descsz, filepos) /* Define away */
84 #define bfd_prpsinfo(abfd, descdata, descsz, filepos) /* Define away */
87 /* Forward data declarations */
89 extern bfd_target elf_little_vec
, elf_big_vec
;
91 /* Currently the elf_symbol_type struct just contains the generic bfd
99 /* Some private data is stashed away for future use using the tdata pointer
100 in the bfd structure. This information is different for ELF core files
101 and other ELF files. */
105 void *prstatus
; /* The raw /proc prstatus structure */
106 void *prpsinfo
; /* The raw /proc prpsinfo structure */
109 #define core_prpsinfo(bfd) (((elf_core_tdata *)((bfd)->tdata))->prpsinfo)
110 #define core_prstatus(bfd) (((elf_core_tdata *)((bfd)->tdata))->prstatus)
114 file_ptr symtab_filepos
; /* Offset to start of ELF symtab section */
115 long symtab_filesz
; /* Size of ELF symtab section */
116 file_ptr strtab_filepos
; /* Offset to start of ELF string tbl section */
117 long strtab_filesz
; /* Size of ELF string tbl section */
120 #define elf_tdata(bfd) ((elf_obj_tdata *) ((bfd) -> tdata))
121 #define elf_symtab_filepos(bfd) (elf_tdata(bfd) -> symtab_filepos)
122 #define elf_symtab_filesz(bfd) (elf_tdata(bfd) -> symtab_filesz)
123 #define elf_strtab_filepos(bfd) (elf_tdata(bfd) -> strtab_filepos)
124 #define elf_strtab_filesz(bfd) (elf_tdata(bfd) -> strtab_filesz)
126 /* Translate an ELF symbol in external format into an ELF symbol in internal
130 DEFUN(elf_swap_symbol_in
,(abfd
, src
, dst
),
132 Elf_External_Sym
*src AND
133 Elf_Internal_Sym
*dst
)
135 dst
-> st_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> st_name
);
136 dst
-> st_value
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> st_value
);
137 dst
-> st_size
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> st_size
);
138 dst
-> st_info
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
-> st_info
);
139 dst
-> st_other
= bfd_h_get_8 (abfd
, (bfd_byte
*) src
-> st_other
);
140 dst
-> st_shndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> st_shndx
);
144 /* Translate an ELF header in external format into an ELF header in internal
148 DEFUN(elf_swap_ehdr_in
,(abfd
, src
, dst
),
150 Elf_External_Ehdr
*src AND
151 Elf_Internal_Ehdr
*dst
)
153 bcopy (src
-> e_ident
, dst
-> e_ident
, EI_NIDENT
);
154 dst
-> e_type
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_type
);
155 dst
-> e_machine
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_machine
);
156 dst
-> e_version
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_version
);
157 dst
-> e_entry
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_entry
);
158 dst
-> e_phoff
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_phoff
);
159 dst
-> e_shoff
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_shoff
);
160 dst
-> e_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> e_flags
);
161 dst
-> e_ehsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_ehsize
);
162 dst
-> e_phentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_phentsize
);
163 dst
-> e_phnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_phnum
);
164 dst
-> e_shentsize
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_shentsize
);
165 dst
-> e_shnum
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_shnum
);
166 dst
-> e_shstrndx
= bfd_h_get_16 (abfd
, (bfd_byte
*) src
-> e_shstrndx
);
170 /* Translate an ELF section header table entry in external format into an
171 ELF section header table entry in internal format. */
174 DEFUN(elf_swap_shdr_in
,(abfd
, src
, dst
),
176 Elf_External_Shdr
*src AND
177 Elf_Internal_Shdr
*dst
)
179 dst
-> sh_name
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_name
);
180 dst
-> sh_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_type
);
181 dst
-> sh_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_flags
);
182 dst
-> sh_addr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_addr
);
183 dst
-> sh_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_offset
);
184 dst
-> sh_size
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_size
);
185 dst
-> sh_link
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_link
);
186 dst
-> sh_info
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_info
);
187 dst
-> sh_addralign
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_addralign
);
188 dst
-> sh_entsize
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> sh_entsize
);
192 /* Translate an ELF program header table entry in external format into an
193 ELF program header table entry in internal format. */
196 DEFUN(elf_swap_phdr_in
,(abfd
, src
, dst
),
198 Elf_External_Phdr
*src AND
199 Elf_Internal_Phdr
*dst
)
201 dst
-> p_type
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_type
);
202 dst
-> p_offset
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_offset
);
203 dst
-> p_vaddr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_vaddr
);
204 dst
-> p_paddr
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_paddr
);
205 dst
-> p_filesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_filesz
);
206 dst
-> p_memsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_memsz
);
207 dst
-> p_flags
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_flags
);
208 dst
-> p_align
= bfd_h_get_32 (abfd
, (bfd_byte
*) src
-> p_align
);
212 /* Create a new bfd section from an ELF section header. */
215 DEFUN(bfd_section_from_shdr
, (abfd
, hdr
, shstrtab
),
217 Elf_Internal_Shdr
*hdr AND
223 name
= hdr
-> sh_name
? shstrtab
+ hdr
-> sh_name
: "unnamed";
224 newsect
= bfd_make_section (abfd
, name
);
225 newsect
-> vma
= hdr
-> sh_addr
;
226 newsect
-> size
= hdr
-> sh_size
;
227 if (!(hdr
-> sh_type
== SHT_NOBITS
))
229 newsect
-> filepos
= hdr
-> sh_offset
;
230 newsect
-> flags
|= SEC_HAS_CONTENTS
;
232 if (hdr
-> sh_flags
& SHF_ALLOC
)
234 newsect
-> flags
|= SEC_ALLOC
;
235 if (hdr
-> sh_type
!= SHT_NOBITS
)
237 newsect
-> flags
|= SEC_LOAD
;
240 if (!(hdr
-> sh_flags
& SHF_WRITE
))
242 newsect
-> flags
|= SEC_READONLY
;
244 if (hdr
-> sh_flags
& SHF_EXECINSTR
)
246 newsect
-> flags
|= SEC_CODE
; /* FIXME: may only contain SOME code */
248 if (hdr
-> sh_type
== SHT_SYMTAB
)
250 abfd
-> flags
|= HAS_SYMS
;
256 /* Create a new bfd section from an ELF program header.
258 Since program segments have no names, we generate a synthetic name
259 of the form segment<NUM>, where NUM is generally the index in the
260 program header table. For segments that are split (see below) we
261 generate the names segment<NUM>a and segment<NUM>b.
263 Note that some program segments may have a file size that is different than
264 (less than) the memory size. All this means is that at execution the
265 system must allocate the amount of memory specified by the memory size,
266 but only initialize it with the first "file size" bytes read from the
267 file. This would occur for example, with program segments consisting
268 of combined data+bss.
270 To handle the above situation, this routine generates TWO bfd sections
271 for the single program segment. The first has the length specified by
272 the file size of the segment, and the second has the length specified
273 by the difference between the two sizes. In effect, the segment is split
274 into it's initialized and uninitialized parts.
279 DEFUN(bfd_section_from_phdr
, (abfd
, hdr
, index
),
281 Elf_Internal_Phdr
*hdr AND
289 split
= ((hdr
-> p_memsz
> 0) &&
290 (hdr
-> p_filesz
> 0) &&
291 (hdr
-> p_memsz
> hdr
-> p_filesz
));
292 sprintf (namebuf
, split
? "segment%da" : "segment%d", index
);
293 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
294 (void) strcpy (name
, namebuf
);
295 newsect
= bfd_make_section (abfd
, name
);
296 newsect
-> vma
= hdr
-> p_vaddr
;
297 newsect
-> size
= hdr
-> p_filesz
;
298 newsect
-> filepos
= hdr
-> p_offset
;
299 newsect
-> flags
|= SEC_HAS_CONTENTS
;
300 if (hdr
-> p_type
== PT_LOAD
)
302 newsect
-> flags
|= SEC_ALLOC
;
303 newsect
-> flags
|= SEC_LOAD
;
304 if (hdr
-> p_flags
& PF_X
)
306 /* FIXME: all we known is that it has execute PERMISSION,
308 newsect
-> flags
|= SEC_CODE
;
311 if (!(hdr
-> p_flags
& PF_W
))
313 newsect
-> flags
|= SEC_READONLY
;
318 sprintf (namebuf
, "segment%db", index
);
319 name
= bfd_alloc (abfd
, strlen (namebuf
) + 1);
320 (void) strcpy (name
, namebuf
);
321 newsect
= bfd_make_section (abfd
, name
);
322 newsect
-> vma
= hdr
-> p_vaddr
+ hdr
-> p_filesz
;
323 newsect
-> size
= hdr
-> p_memsz
- hdr
-> p_filesz
;
324 if (hdr
-> p_type
== PT_LOAD
)
326 newsect
-> flags
|= SEC_ALLOC
;
327 if (hdr
-> p_flags
& PF_X
)
329 newsect
-> flags
|= SEC_CODE
;
332 if (!(hdr
-> p_flags
& PF_W
))
334 newsect
-> flags
|= SEC_READONLY
;
344 DEFUN(bfd_prstatus
,(abfd
, descdata
, descsz
, filepos
),
352 if (descsz
== sizeof (prstatus_t
))
354 newsect
= bfd_make_section (abfd
, ".reg");
355 newsect
-> size
= sizeof (gregset_t
);
356 newsect
-> filepos
= filepos
+ (long) (((prstatus_t
*)0) -> pr_reg
);
357 newsect
-> flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
358 newsect
-> alignment_power
= 2;
359 if ((core_prstatus (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
361 bcopy (descdata
, core_prstatus (abfd
), descsz
);
366 /* Stash a copy of the prpsinfo structure away for future use. */
369 DEFUN(bfd_prpsinfo
,(abfd
, descdata
, descsz
, filepos
),
377 if (descsz
== sizeof (prpsinfo_t
))
379 if ((core_prpsinfo (abfd
) = bfd_alloc (abfd
, descsz
)) != NULL
)
381 bcopy (descdata
, core_prpsinfo (abfd
), descsz
);
387 DEFUN(bfd_fpregset
,(abfd
, descdata
, descsz
, filepos
),
395 if (descsz
== sizeof (fpregset_t
))
397 newsect
= bfd_make_section (abfd
, ".reg2");
398 newsect
-> size
= sizeof (fpregset_t
);
399 newsect
-> filepos
= filepos
;
400 newsect
-> flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
401 newsect
-> alignment_power
= 2;
405 #endif /* HAVE_PROCFS */
407 /* Return a pointer to the args (including the command name) that were
408 seen by the program that generated the core dump. Note that for
409 some reason, a spurious space is tacked onto the end of the args
410 in some (at least one anyway) implementations, so strip it off if
414 DEFUN(elf_core_file_failing_command
, (abfd
),
418 if (core_prpsinfo (abfd
))
420 prpsinfo_t
*p
= core_prpsinfo (abfd
);
421 char *scan
= p
-> pr_psargs
;
424 if ((scan
> p
-> pr_psargs
) && (*scan
== ' '))
428 return (p
-> pr_psargs
);
434 /* Return the number of the signal that caused the core dump. Presumably,
435 since we have a core file, we got a signal of some kind, so don't bother
436 checking the other process status fields, just return the signal number.
440 DEFUN(elf_core_file_failing_signal
, (abfd
),
444 if (core_prstatus (abfd
))
446 return (((prstatus_t
*)(core_prstatus (abfd
))) -> pr_cursig
);
452 /* Check to see if the core file could reasonably be expected to have
453 come for the current executable file. Note that by default we return
454 true unless we find something that indicates that there might be a
459 DEFUN(elf_core_file_matches_executable_p
, (core_bfd
, exec_bfd
),
466 /* First, xvecs must match since both are ELF files for the same target. */
468 if (core_bfd
->xvec
!= exec_bfd
->xvec
)
470 bfd_error
= system_call_error
;
476 /* If no prpsinfo, just return true. Otherwise, grab the last component
477 of the exec'd pathname from the prpsinfo. */
479 if (core_prpsinfo (core_bfd
))
481 corename
= (((struct prpsinfo
*) core_prpsinfo (core_bfd
)) -> pr_fname
);
488 /* Find the last component of the executable pathname. */
490 if ((execname
= strrchr (exec_bfd
-> filename
, '/')) != NULL
)
496 execname
= (char *) exec_bfd
-> filename
;
499 /* See if they match */
501 return (strcmp (execname
, corename
) ? false : true);
507 #endif /* HAVE_PROCFS */
510 /* ELF core files contain a segment of type PT_NOTE, that holds much of
511 the information that would normally be available from the /proc interface
512 for the process, at the time the process dumped core. Currently this
513 includes copies of the prstatus, prpsinfo, and fpregset structures.
515 Since these structures are potentially machine dependent in size and
516 ordering, bfd provides two levels of support for them. The first level,
517 available on all machines since it does not require that the host
518 have /proc support or the relevant include files, is to create a bfd
519 section for each of the prstatus, prpsinfo, and fpregset structures,
520 without any interpretation of their contents. With just this support,
521 the bfd client will have to interpret the structures itself. Even with
522 /proc support, it might want these full structures for it's own reasons.
524 In the second level of support, where HAVE_PROCFS is defined, bfd will
525 pick apart the structures to gather some additional information that
526 clients may want, such as the general register set, the name of the
527 exec'ed file and its arguments, the signal (if any) that caused the
533 DEFUN(elf_corefile_note
, (abfd
, hdr
),
535 Elf_Internal_Phdr
*hdr
)
537 Elf_External_Note
*x_note_p
; /* Elf note, external form */
538 Elf_Internal_Note i_note
; /* Elf note, internal form */
539 char *buf
= NULL
; /* Entire note segment contents */
540 char *namedata
; /* Name portion of the note */
541 char *descdata
; /* Descriptor portion of the note */
542 char *sectname
; /* Name to use for new section */
543 long filepos
; /* File offset to descriptor data */
546 if (hdr
-> p_filesz
> 0
547 && (buf
= malloc (hdr
-> p_filesz
)) != NULL
548 && bfd_seek (abfd
, hdr
-> p_offset
, SEEK_SET
) != -1L
549 && bfd_read ((PTR
) buf
, hdr
-> p_filesz
, 1, abfd
) == hdr
-> p_filesz
)
551 x_note_p
= (Elf_External_Note
*) buf
;
552 while ((char *) x_note_p
< (buf
+ hdr
-> p_filesz
))
554 i_note
.namesz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
-> namesz
);
555 i_note
.descsz
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
-> descsz
);
556 i_note
.type
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_note_p
-> type
);
557 namedata
= x_note_p
-> name
;
558 descdata
= namedata
+ BFD_ALIGN (i_note
.namesz
, 4);
559 filepos
= hdr
-> p_offset
+ (descdata
- buf
);
560 switch (i_note
.type
) {
562 /* process descdata as prstatus info */
563 bfd_prstatus (abfd
, descdata
, i_note
.descsz
, filepos
);
564 sectname
= ".prstatus";
567 /* process descdata as fpregset info */
568 bfd_fpregset (abfd
, descdata
, i_note
.descsz
, filepos
);
569 sectname
= ".fpregset";
572 /* process descdata as prpsinfo */
573 bfd_prpsinfo (abfd
, descdata
, i_note
.descsz
, filepos
);
574 sectname
= ".prpsinfo";
577 /* Unknown descriptor, just ignore it. */
581 if (sectname
!= NULL
)
583 newsect
= bfd_make_section (abfd
, sectname
);
584 newsect
-> size
= i_note
.descsz
;
585 newsect
-> filepos
= filepos
;
586 newsect
-> flags
= SEC_ALLOC
| SEC_HAS_CONTENTS
;
587 newsect
-> alignment_power
= 2;
589 x_note_p
= (Elf_External_Note
*)
590 (descdata
+ BFD_ALIGN (i_note
.descsz
, 4));
600 /* Begin processing a given object.
602 First we validate the file by reading in the ELF header and checking
608 DEFUN (elf_object_p
, (abfd
), bfd
*abfd
)
610 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
611 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
612 Elf_External_Shdr
*x_shdr
; /* Section header table, external form */
613 Elf_Internal_Shdr
*i_shdr
; /* Section header table, internal form */
615 char *shstrtab
; /* Internal copy of section header stringtab */
616 int shstrtabsize
; /* Size of section header string table */
618 /* Read in the ELF header in external format. */
620 if (bfd_read ((PTR
) &x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
622 bfd_error
= system_call_error
;
626 /* Now check to see if we have a valid ELF file, and one that BFD can
627 make use of. The magic number must match, the address size ('class')
628 and byte-swapping must match our XVEC entry, and it must have a
629 section header table (FIXME: See comments re sections at top of this
632 if (x_ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
||
633 x_ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
||
634 x_ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
||
635 x_ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
638 bfd_error
= wrong_format
;
642 /* FIXME, Check EI_VERSION here ! */
644 switch (x_ehdr
.e_ident
[EI_CLASS
]) {
645 case ELFCLASSNONE
: /* address size not specified */
646 goto wrong
; /* No support if can't tell address size */
647 case ELFCLASS32
: /* 32-bit addresses */
649 case ELFCLASS64
: /* 64-bit addresses */
650 goto wrong
; /* FIXME: 64 bits not yet supported */
652 goto wrong
; /* No support if unknown address class */
655 /* Switch xvec to match the specified byte order. */
656 switch (x_ehdr
.e_ident
[EI_DATA
]) {
657 case ELFDATA2MSB
: /* Big-endian */
658 abfd
->xvec
= &elf_big_vec
;
660 case ELFDATA2LSB
: /* Little-endian */
661 abfd
->xvec
= &elf_little_vec
;
662 case ELFDATANONE
: /* No data encoding specified */
663 default: /* Unknown data encoding specified */
667 /* Allocate an instance of the elf_obj_tdata structure and hook it up to
668 the tdata pointer in the bfd. */
670 if ((abfd
-> tdata
= bfd_zalloc (abfd
, sizeof (elf_obj_tdata
))) == NULL
)
672 bfd_error
= no_memory
;
676 /* Now that we know the byte order, swap in the rest of the header */
677 elf_swap_ehdr_in (abfd
, &x_ehdr
, &i_ehdr
);
679 /* If there is no section header table, we're hosed. */
680 if (i_ehdr
.e_shoff
== 0)
683 if (i_ehdr
.e_type
== ET_EXEC
|| i_ehdr
.e_type
== ET_DYN
)
685 abfd
-> flags
|= EXEC_P
;
688 /* Allocate space for copies of the section header table in external
689 and internal form, seek to the section header table in the file,
690 read it in, and convert it to internal form. As a simple sanity
691 check, verify that the what BFD thinks is the size of each section
692 header table entry actually matches the size recorded in the file. */
694 if (i_ehdr
.e_shentsize
!= sizeof (*x_shdr
))
696 if ((x_shdr
= (Elf_External_Shdr
*)
697 bfd_alloc (abfd
, sizeof (*x_shdr
) * i_ehdr
.e_shnum
)) == NULL
)
699 bfd_error
= no_memory
;
702 if ((i_shdr
= (Elf_Internal_Shdr
*)
703 bfd_alloc (abfd
, sizeof (*i_shdr
) * i_ehdr
.e_shnum
)) == NULL
)
705 bfd_error
= no_memory
;
708 if (bfd_seek (abfd
, i_ehdr
.e_shoff
, SEEK_SET
) == -1)
710 bfd_error
= system_call_error
;
713 for (shindex
= 0; shindex
< i_ehdr
.e_shnum
; shindex
++)
715 if (bfd_read ((PTR
) (x_shdr
+ shindex
), sizeof (*x_shdr
), 1, abfd
)
718 bfd_error
= system_call_error
;
721 elf_swap_shdr_in (abfd
, x_shdr
+ shindex
, i_shdr
+ shindex
);
724 /* Read in the string table containing the names of the sections. We
725 will need the base pointer to this table later. */
727 shstrtabsize
= i_shdr
[i_ehdr
.e_shstrndx
].sh_size
;
728 if ((shstrtab
= bfd_alloc (abfd
, shstrtabsize
)) == NULL
)
730 bfd_error
= no_memory
;
733 if (bfd_seek (abfd
, i_shdr
[i_ehdr
.e_shstrndx
].sh_offset
, SEEK_SET
) == -1)
735 bfd_error
= system_call_error
;
738 if (bfd_read ((PTR
) shstrtab
, shstrtabsize
, 1, abfd
) != shstrtabsize
)
740 bfd_error
= system_call_error
;
744 /* Once all of the section headers have been read and converted, we
745 can start processing them. Note that the first section header is
746 a dummy placeholder entry, so we ignore it.
748 We also watch for the symbol table section and remember the file
749 offset and section size for both the symbol table section and the
750 associated string table section. */
752 for (shindex
= 1; shindex
< i_ehdr
.e_shnum
; shindex
++)
754 Elf_Internal_Shdr
*hdr
= i_shdr
+ shindex
;
755 bfd_section_from_shdr (abfd
, hdr
, shstrtab
);
756 if (hdr
-> sh_type
== SHT_SYMTAB
)
758 elf_symtab_filepos(abfd
) = hdr
-> sh_offset
;
759 elf_symtab_filesz(abfd
) = hdr
-> sh_size
;
760 elf_strtab_filepos(abfd
) = (i_shdr
+ hdr
-> sh_link
) -> sh_offset
;
761 elf_strtab_filesz(abfd
) = (i_shdr
+ hdr
-> sh_link
) -> sh_size
;
768 /* Core files are simply standard ELF formatted files that partition
769 the file using the execution view of the file (program header table)
770 rather than the linking view. In fact, there is no section header
771 table in a core file.
773 The process status information (including the contents of the general
774 register set) and the floating point register set are stored in a
775 segment of type PT_NOTE. We handcraft a couple of extra bfd sections
776 that allow standard bfd access to the general registers (.reg) and the
777 floating point registers (.reg2).
782 DEFUN (elf_core_file_p
, (abfd
), bfd
*abfd
)
784 Elf_External_Ehdr x_ehdr
; /* Elf file header, external form */
785 Elf_Internal_Ehdr i_ehdr
; /* Elf file header, internal form */
786 Elf_External_Phdr
*x_phdr
; /* Program header table, external form */
787 Elf_Internal_Phdr
*i_phdr
; /* Program header table, internal form */
790 /* Read in the ELF header in external format. */
792 if (bfd_read ((PTR
) &x_ehdr
, sizeof (x_ehdr
), 1, abfd
) != sizeof (x_ehdr
))
794 bfd_error
= system_call_error
;
798 /* Now check to see if we have a valid ELF file, and one that BFD can
799 make use of. The magic number must match, the address size ('class')
800 and byte-swapping must match our XVEC entry, and it must have a
801 program header table (FIXME: See comments re segments at top of this
804 if (x_ehdr
.e_ident
[EI_MAG0
] != ELFMAG0
||
805 x_ehdr
.e_ident
[EI_MAG1
] != ELFMAG1
||
806 x_ehdr
.e_ident
[EI_MAG2
] != ELFMAG2
||
807 x_ehdr
.e_ident
[EI_MAG3
] != ELFMAG3
)
810 bfd_error
= wrong_format
;
814 /* FIXME, Check EI_VERSION here ! */
816 switch (x_ehdr
.e_ident
[EI_CLASS
]) {
817 case ELFCLASSNONE
: /* address size not specified */
818 goto wrong
; /* No support if can't tell address size */
819 case ELFCLASS32
: /* 32-bit addresses */
821 case ELFCLASS64
: /* 64-bit addresses */
822 goto wrong
; /* FIXME: 64 bits not yet supported */
824 goto wrong
; /* No support if unknown address class */
827 /* Switch xvec to match the specified byte order. */
828 switch (x_ehdr
.e_ident
[EI_DATA
]) {
829 case ELFDATA2MSB
: /* Big-endian */
830 abfd
->xvec
= &elf_big_vec
;
832 case ELFDATA2LSB
: /* Little-endian */
833 abfd
->xvec
= &elf_little_vec
;
834 case ELFDATANONE
: /* No data encoding specified */
835 default: /* Unknown data encoding specified */
839 /* Now that we know the byte order, swap in the rest of the header */
840 elf_swap_ehdr_in (abfd
, &x_ehdr
, &i_ehdr
);
842 /* If there is no program header, or the type is not a core file, then
844 if (i_ehdr
.e_phoff
== 0 || i_ehdr
.e_type
!= ET_CORE
)
847 /* Allocate an instance of the elf_core_tdata structure and hook it up to
848 the tdata pointer in the bfd. */
850 if ((abfd
-> tdata
= bfd_zalloc (abfd
, sizeof (elf_core_tdata
))) == NULL
)
852 bfd_error
= no_memory
;
856 /* Allocate space for copies of the program header table in external
857 and internal form, seek to the program header table in the file,
858 read it in, and convert it to internal form. As a simple sanity
859 check, verify that the what BFD thinks is the size of each program
860 header table entry actually matches the size recorded in the file. */
862 if (i_ehdr
.e_phentsize
!= sizeof (*x_phdr
))
864 if ((x_phdr
= (Elf_External_Phdr
*)
865 bfd_alloc (abfd
, sizeof (*x_phdr
) * i_ehdr
.e_phnum
)) == NULL
)
867 bfd_error
= no_memory
;
870 if ((i_phdr
= (Elf_Internal_Phdr
*)
871 bfd_alloc (abfd
, sizeof (*i_phdr
) * i_ehdr
.e_phnum
)) == NULL
)
873 bfd_error
= no_memory
;
876 if (bfd_seek (abfd
, i_ehdr
.e_phoff
, SEEK_SET
) == -1)
878 bfd_error
= system_call_error
;
881 for (phindex
= 0; phindex
< i_ehdr
.e_phnum
; phindex
++)
883 if (bfd_read ((PTR
) (x_phdr
+ phindex
), sizeof (*x_phdr
), 1, abfd
)
886 bfd_error
= system_call_error
;
889 elf_swap_phdr_in (abfd
, x_phdr
+ phindex
, i_phdr
+ phindex
);
892 /* Once all of the program headers have been read and converted, we
893 can start processing them. */
895 for (phindex
= 0; phindex
< i_ehdr
.e_phnum
; phindex
++)
897 bfd_section_from_phdr (abfd
, i_phdr
+ phindex
, phindex
);
898 if ((i_phdr
+ phindex
) -> p_type
== PT_NOTE
)
900 elf_corefile_note (abfd
, i_phdr
+ phindex
);
908 DEFUN (elf_mkobject
, (abfd
), bfd
*abfd
)
910 fprintf (stderr
, "elf_mkobject unimplemented\n");
917 DEFUN (elf_write_object_contents
, (abfd
), bfd
*abfd
)
919 fprintf (stderr
, "elf_write_object_contents unimplemented\n");
925 /* Given an index of a section, retrieve a pointer to it. Note
926 that for our purposes, sections are indexed by {1, 2, ...} with
927 0 being an illegal index. */
930 DEFUN (section_from_bfd_index
, (abfd
, index
),
936 struct sec
*answer
= abfd
-> sections
;
939 answer
= answer
-> next
;
947 DEFUN (elf_slurp_symbol_table
, (abfd
), bfd
*abfd
)
949 int symcount
; /* Number of external ELF symbols */
950 char *strtab
; /* Buffer for raw ELF string table section */
951 asymbol
*sym
; /* Pointer to current bfd symbol */
952 asymbol
*symbase
; /* Buffer for generated bfd symbols */
953 asymbol
**vec
; /* Pointer to current bfd symbol pointer */
954 Elf_Internal_Sym i_sym
;
955 Elf_External_Sym x_sym
;
957 if (bfd_get_outsymbols (abfd
) != NULL
)
962 /* Slurp in the string table. We will keep it around permanently, as
963 long as the bfd is in use, since we will end up setting up pointers
964 into it for the names of all the symbols. */
966 if (bfd_seek (abfd
, elf_strtab_filepos (abfd
), SEEK_SET
) == -1)
968 bfd_error
= system_call_error
;
971 if ((strtab
= bfd_alloc (abfd
, elf_strtab_filesz (abfd
))) == NULL
)
973 bfd_error
= system_call_error
;
976 if (bfd_read ((PTR
) strtab
, elf_strtab_filesz (abfd
), 1, abfd
) !=
977 elf_strtab_filesz (abfd
))
979 bfd_error
= system_call_error
;
983 /* Read each raw ELF symbol, converting from external ELF form to
984 internal ELF form, and then using the information to create a
985 canonical bfd symbol table entry.
987 Note that be allocate the initial bfd canonical symbol buffer
988 based on a one-to-one mapping of the ELF symbols to canonical
989 symbols. However, it is likely that not all the ELF symbols will
990 be used, so there will be some space leftover at the end. Once
991 we know how many symbols we actual generate, we realloc the buffer
992 to the correct size and then build the pointer vector. */
994 if (bfd_seek (abfd
, elf_symtab_filepos (abfd
), SEEK_SET
) == -1)
996 bfd_error
= system_call_error
;
1000 symcount
= elf_symtab_filesz(abfd
) / sizeof (Elf_External_Sym
);
1001 sym
= symbase
= (asymbol
*) bfd_zalloc (abfd
, symcount
* sizeof (asymbol
));
1003 while (symcount
-- > 0)
1005 if (bfd_read ((PTR
) &x_sym
, sizeof (x_sym
), 1, abfd
) != sizeof (x_sym
))
1007 bfd_error
= system_call_error
;
1010 elf_swap_symbol_in (abfd
, &x_sym
, &i_sym
);
1011 if (i_sym
.st_name
> 0)
1013 sym
-> the_bfd
= abfd
;
1014 sym
-> name
= strtab
+ i_sym
.st_name
;
1015 sym
-> value
= i_sym
.st_value
;
1016 if (i_sym
.st_shndx
> 0 && i_sym
.st_shndx
< SHN_LORESERV
)
1018 /* Note: This code depends upon there being an ordered
1019 one-for-one mapping of ELF sections to bfd sections. */
1020 sym
-> section
= section_from_bfd_index (abfd
, i_sym
.st_shndx
);
1022 else if (i_sym
.st_shndx
== SHN_ABS
)
1024 sym
-> flags
|= BSF_ABSOLUTE
;
1026 else if (i_sym
.st_shndx
== SHN_COMMON
)
1028 sym
-> flags
|= BSF_FORT_COMM
;
1030 switch (ELF_ST_BIND (i_sym
.st_info
))
1033 sym
-> flags
|= BSF_LOCAL
;
1036 sym
-> flags
|= (BSF_GLOBAL
| BSF_EXPORT
);
1039 sym
-> flags
|= BSF_WEAK
;
1046 bfd_get_symcount(abfd
) = symcount
= sym
- symbase
;
1047 sym
= symbase
= (asymbol
*)
1048 bfd_realloc (abfd
, symbase
, symcount
* sizeof (asymbol
));
1049 bfd_get_outsymbols(abfd
) = vec
= (asymbol
**)
1050 bfd_alloc (abfd
, symcount
* sizeof (asymbol
*));
1052 while (symcount
-- > 0)
1060 /* Return the number of bytes required to hold the symtab vector.
1062 Note that we base it on the count plus 1, since we will null terminate
1063 the vector allocated based on this size. */
1066 DEFUN (elf_get_symtab_upper_bound
, (abfd
), bfd
*abfd
)
1068 unsigned int symtab_size
= 0;
1070 if (elf_slurp_symbol_table (abfd
))
1072 symtab_size
= (bfd_get_symcount (abfd
) + 1) * (sizeof (asymbol
));
1074 return (symtab_size
);
1078 elf_get_reloc_upper_bound (abfd
, asect
)
1082 fprintf (stderr
, "elf_get_reloc_upper_bound unimplemented\n");
1089 elf_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
1095 fprintf (stderr
, "elf_canonicalize_reloc unimplemented\n");
1102 DEFUN (elf_get_symtab
, (abfd
, alocation
),
1104 asymbol
**alocation
)
1106 unsigned int symcount
;
1109 if (!elf_slurp_symbol_table (abfd
))
1115 symcount
= bfd_get_symcount (abfd
);
1116 vec
= bfd_get_outsymbols (abfd
);
1117 while (symcount
-- > 0)
1119 *alocation
++ = *vec
++;
1121 *alocation
++ = NULL
;
1122 return (bfd_get_symcount (abfd
));
1127 elf_make_empty_symbol(abfd
)
1130 fprintf (stderr
, "elf_make_empty_symbol unimplemented\n");
1137 DEFUN (elf_print_symbol
,(ignore_abfd
, filep
, symbol
, how
),
1138 bfd
*ignore_abfd AND
1141 bfd_print_symbol_type how
)
1143 fprintf (stderr
, "elf_print_symbol unimplemented\n");
1149 DEFUN (elf_get_lineno
,(ignore_abfd
, symbol
),
1150 bfd
*ignore_abfd AND
1153 fprintf (stderr
, "elf_get_lineno unimplemented\n");
1160 DEFUN (elf_set_arch_mach
,(abfd
, arch
, machine
),
1162 enum bfd_architecture arch AND
1163 unsigned long machine
)
1165 fprintf (stderr
, "elf_set_arch_mach unimplemented\n");
1167 /* Allow any architecture to be supported by the elf backend */
1168 return bfd_default_set_arch_mach(abfd
, arch
, machine
);
1172 DEFUN (elf_find_nearest_line
,(abfd
,
1180 asection
*section AND
1181 asymbol
**symbols AND
1183 CONST
char **filename_ptr AND
1184 CONST
char **functionname_ptr AND
1185 unsigned int *line_ptr
)
1187 fprintf (stderr
, "elf_find_nearest_line unimplemented\n");
1194 DEFUN (elf_sizeof_headers
, (abfd
, reloc
),
1198 fprintf (stderr
, "elf_sizeof_headers unimplemented\n");
1204 /* This structure contains everything that BFD knows about a target.
1205 It includes things like its byte order, name, what routines to call
1206 to do various operations, etc. Every BFD points to a target structure
1207 with its "xvec" member.
1209 There are two such structures here: one for big-endian machines and
1210 one for little-endian machines. */
1212 /* Archives are generic or unimplemented. */
1213 #define elf_slurp_armap bfd_false
1214 #define elf_slurp_extended_name_table _bfd_slurp_extended_name_table
1215 #define elf_truncate_arname bfd_dont_truncate_arname
1216 #define elf_openr_next_archived_file bfd_generic_openr_next_archived_file
1217 #define elf_generic_stat_arch_elt bfd_generic_stat_arch_elt
1218 #define elf_write_armap (PROTO (boolean, (*), \
1219 (bfd *arch, unsigned int elength, struct orl *map, unsigned int orl_count, \
1220 int stridx))) bfd_false
1222 /* Ordinary section reading and writing */
1223 #define elf_new_section_hook _bfd_dummy_new_section_hook
1224 #define elf_get_section_contents bfd_generic_get_section_contents
1225 #define elf_set_section_contents bfd_generic_set_section_contents
1226 #define elf_close_and_cleanup bfd_generic_close_and_cleanup
1228 #define elf_bfd_debug_info_start bfd_void
1229 #define elf_bfd_debug_info_end bfd_void
1230 #define elf_bfd_debug_info_accumulate (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
1232 bfd_target elf_big_vec
=
1234 /* name: identify kind of target */
1237 /* flavour: general indication about file */
1238 bfd_target_elf_flavour
,
1240 /* byteorder_big_p: data is big endian */
1243 /* header_byteorder_big_p: header is also big endian */
1246 /* object_flags: mask of all file flags */
1247 (HAS_RELOC
| EXEC_P
| HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
|
1250 /* section_flags: mask of all section flags */
1251 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
|
1254 /* ar_pad_char: pad character for filenames within an archive header
1255 FIXME: this really has nothing to do with ELF, this is a characteristic
1256 of the archiver and/or os and should be independently tunable */
1259 /* ar_max_namelen: maximum number of characters in an archive header
1260 FIXME: this really has nothing to do with ELF, this is a characteristic
1261 of the archiver and should be independently tunable. This value is
1262 a WAG (wild a** guess) */
1265 /* align_power_min: minimum alignment restriction for any section
1266 FIXME: this value may be target machine dependent */
1269 /* Routines to byte-swap various sized integers from the data sections */
1270 _do_getb64
, _do_putb64
, _do_getb32
, _do_putb32
, _do_getb16
, _do_putb16
,
1272 /* Routines to byte-swap various sized integers from the file headers */
1273 _do_getb64
, _do_putb64
, _do_getb32
, _do_putb32
, _do_getb16
, _do_putb16
,
1275 /* bfd_check_format: check the format of a file being read */
1276 { _bfd_dummy_target
, /* unknown format */
1277 elf_object_p
, /* assembler/linker output (object file) */
1278 bfd_generic_archive_p
, /* an archive */
1279 elf_core_file_p
/* a core file */
1282 /* bfd_set_format: set the format of a file being written */
1285 _bfd_generic_mkarchive
,
1289 /* bfd_write_contents: write cached information into a file being written */
1291 elf_write_object_contents
,
1292 _bfd_write_archive_contents
,
1296 /* Initialize a jump table with the standard macro. All names start
1304 bfd_target elf_little_vec
=
1306 /* name: identify kind of target */
1309 /* flavour: general indication about file */
1310 bfd_target_elf_flavour
,
1312 /* byteorder_big_p: data is big endian */
1313 false, /* Nope -- this one's little endian */
1315 /* header_byteorder_big_p: header is also big endian */
1316 false, /* Nope -- this one's little endian */
1318 /* object_flags: mask of all file flags */
1319 (HAS_RELOC
| EXEC_P
| HAS_LINENO
| HAS_DEBUG
| HAS_SYMS
| HAS_LOCALS
|
1322 /* section_flags: mask of all section flags */
1323 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_READONLY
|
1326 /* ar_pad_char: pad character for filenames within an archive header
1327 FIXME: this really has nothing to do with ELF, this is a characteristic
1328 of the archiver and/or os and should be independently tunable */
1331 /* ar_max_namelen: maximum number of characters in an archive header
1332 FIXME: this really has nothing to do with ELF, this is a characteristic
1333 of the archiver and should be independently tunable. This value is
1334 a WAG (wild a** guess) */
1337 /* align_power_min: minimum alignment restriction for any section
1338 FIXME: this value may be target machine dependent */
1341 /* Routines to byte-swap various sized integers from the data sections */
1342 _do_getl64
, _do_putl64
, _do_getl32
, _do_putl32
, _do_getl16
, _do_putl16
,
1344 /* Routines to byte-swap various sized integers from the file headers */
1345 _do_getl64
, _do_putl64
, _do_getl32
, _do_putl32
, _do_getl16
, _do_putl16
,
1347 /* bfd_check_format: check the format of a file being read */
1348 { _bfd_dummy_target
, /* unknown format */
1349 elf_object_p
, /* assembler/linker output (object file) */
1350 bfd_generic_archive_p
, /* an archive */
1351 elf_core_file_p
/* a core file */
1354 /* bfd_set_format: set the format of a file being written */
1357 _bfd_generic_mkarchive
,
1361 /* bfd_write_contents: write cached information into a file being written */
1363 elf_write_object_contents
,
1364 _bfd_write_archive_contents
,
1368 /* Initialize a jump table with the standard macro. All names start