Move to the start of the program headers before attempting to read them.
[external/binutils.git] / bfd / elfcore.h
1 /* ELF core file support for BFD.
2    Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
19
20
21 char*
22 elf_core_file_failing_command (abfd)
23      bfd *abfd;
24 {
25   return elf_tdata (abfd)->core_command;
26 }
27
28 int
29 elf_core_file_failing_signal (abfd)
30      bfd *abfd;
31 {
32   return elf_tdata (abfd)->core_signal;
33 }
34
35
36 boolean
37 elf_core_file_matches_executable_p (core_bfd, exec_bfd)
38      bfd *core_bfd;
39      bfd *exec_bfd;
40 {
41   char* corename;
42
43   /* xvecs must match if both are ELF files for the same target. */
44
45   if (core_bfd->xvec != exec_bfd->xvec)
46     {
47       bfd_set_error (bfd_error_system_call);
48       return false;
49     }
50
51   /* See if the name in the corefile matches the executable name. */
52
53   corename = elf_tdata (core_bfd)->core_program;
54   if (corename != NULL)
55     {
56       const char* execname = strrchr (exec_bfd->filename, '/');
57       execname = execname ? execname + 1 : exec_bfd->filename;
58
59       if (strcmp(execname, corename) != 0)
60         return false;
61     }
62
63   return true;
64 }
65
66
67 /*  Core files are simply standard ELF formatted files that partition
68     the file using the execution view of the file (program header table)
69     rather than the linking view.  In fact, there is no section header
70     table in a core file.
71
72     The process status information (including the contents of the general
73     register set) and the floating point register set are stored in a
74     segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
75     that allow standard bfd access to the general registers (.reg) and the
76     floating point registers (.reg2).
77
78  */
79
80 const bfd_target *
81 elf_core_file_p (abfd)
82      bfd *abfd;
83 {
84   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
85   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
86   Elf_Internal_Phdr *i_phdrp = NULL;    /* Elf program header, internal form */
87   unsigned int phindex;
88   struct elf_backend_data *ebd;
89   struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
90   struct elf_obj_tdata *new_tdata = NULL;
91
92   /* Read in the ELF header in external format.  */
93   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
94     {
95       if (bfd_get_error () != bfd_error_system_call)
96         bfd_set_error (bfd_error_wrong_format);
97       return NULL;
98     }
99
100   /* Check the magic number. */
101   if (elf_file_p (&x_ehdr) == false)
102     goto wrong;
103
104   /* FIXME: Check EI_VERSION here ! */
105
106   /* Check the address size ("class"). */
107   if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
108     goto wrong;
109
110   /* Check the byteorder. */
111   switch (x_ehdr.e_ident[EI_DATA])
112     {
113     case ELFDATA2MSB:           /* Big-endian */
114       if (! bfd_big_endian (abfd))
115         goto wrong;
116       break;
117     case ELFDATA2LSB:           /* Little-endian */
118       if (! bfd_little_endian (abfd))
119         goto wrong;
120       break;
121     default:
122       goto wrong;
123     }
124
125   /* Give abfd an elf_obj_tdata. */
126   new_tdata = 
127     (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
128   if (new_tdata == NULL)
129     return NULL;
130   elf_tdata (abfd) = new_tdata;  
131
132   /* Swap in the rest of the header, now that we have the byte order. */
133   i_ehdrp = elf_elfheader (abfd);
134   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
135
136 #if DEBUG & 1
137   elf_debug_file (i_ehdrp);
138 #endif
139
140   ebd = get_elf_backend_data (abfd);
141
142   /* Check that the ELF e_machine field matches what this particular
143      BFD format expects.  */
144
145   if (ebd->elf_machine_code != i_ehdrp->e_machine
146       && (ebd->elf_machine_alt1 == 0
147           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
148       && (ebd->elf_machine_alt2 == 0
149           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
150     {
151       const bfd_target * const *target_ptr;
152
153       if (ebd->elf_machine_code != EM_NONE)
154         goto wrong;
155
156       /* This is the generic ELF target.  Let it match any ELF target
157          for which we do not have a specific backend.  */
158
159       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
160         {
161           struct elf_backend_data *back;
162
163           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
164             continue;
165           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
166           if (back->elf_machine_code == i_ehdrp->e_machine)
167             {
168               /* target_ptr is an ELF backend which matches this
169                  object file, so reject the generic ELF target.  */
170               goto wrong;
171             }
172         }
173     }
174
175   /* If there is no program header, or the type is not a core file, then
176      we are hosed. */
177   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
178     goto wrong;
179
180   /* Does BFD's idea of the phdr size match the size
181      recorded in the file? */
182   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
183     goto wrong;
184
185   /* Move to the start of the program headers.  */
186   if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0)
187     goto wrong;
188   
189   /* Allocate space for the program headers. */
190   i_phdrp = (Elf_Internal_Phdr *)
191     bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
192   if (!i_phdrp)
193     goto fail;
194
195   elf_tdata (abfd)->phdr = i_phdrp;
196
197   /* Read and convert to internal form. */
198   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
199     {
200       Elf_External_Phdr x_phdr;
201       if (bfd_read ((PTR) &x_phdr, sizeof (x_phdr), 1, abfd)
202           != sizeof (x_phdr))
203         goto fail;
204
205       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
206     }
207
208   /* Process each program header. */
209   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
210     {
211       if (!_bfd_elfcore_section_from_phdr (abfd, i_phdrp + phindex, phindex))
212         goto fail;
213     }
214
215   /* Set the machine architecture. */
216   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
217     {
218       /* It's OK if this fails for the generic target.  */
219       if (ebd->elf_machine_code != EM_NONE)
220         goto fail;
221     }
222
223   /* Save the entry point from the ELF header. */
224   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
225
226   /* Let the backend double check the format and override global
227      information.  */
228   if (ebd->elf_backend_object_p)
229     {
230       if ((*ebd->elf_backend_object_p) (abfd) == false)
231         goto wrong;
232     }
233
234   return abfd->xvec;
235
236 wrong:
237   bfd_set_error (bfd_error_wrong_format);
238 fail:
239   if (i_phdrp != NULL)
240     bfd_release (abfd, i_phdrp);
241   if (new_tdata != NULL)
242     bfd_release (abfd, new_tdata);
243   elf_tdata (abfd) = preserved_tdata;
244   return NULL;
245 }