1/* ELF core file support for BFD.
2   Copyright 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2005
3   Free Software Foundation, Inc.
4
5   This file is part of BFD, the Binary File Descriptor library.
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2 of the License, or
10   (at your option) any later version.
11
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; if not, write to the Free Software
19   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
20
21char*
22elf_core_file_failing_command (bfd *abfd)
23{
24  return elf_tdata (abfd)->core_command;
25}
26
27int
28elf_core_file_failing_signal (bfd *abfd)
29{
30  return elf_tdata (abfd)->core_signal;
31}
32
33bfd_boolean
34elf_core_file_matches_executable_p (bfd *core_bfd, bfd *exec_bfd)
35{
36  char* corename;
37
38  /* xvecs must match if both are ELF files for the same target.  */
39
40  if (core_bfd->xvec != exec_bfd->xvec)
41    {
42      bfd_set_error (bfd_error_system_call);
43      return FALSE;
44    }
45
46  /* See if the name in the corefile matches the executable name.  */
47  corename = elf_tdata (core_bfd)->core_program;
48  if (corename != NULL)
49    {
50      const char* execname = strrchr (exec_bfd->filename, '/');
51
52      execname = execname ? execname + 1 : exec_bfd->filename;
53
54      if (strcmp (execname, corename) != 0)
55	return FALSE;
56    }
57
58  return TRUE;
59}
60
61/*  Core files are simply standard ELF formatted files that partition
62    the file using the execution view of the file (program header table)
63    rather than the linking view.  In fact, there is no section header
64    table in a core file.
65
66    The process status information (including the contents of the general
67    register set) and the floating point register set are stored in a
68    segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
69    that allow standard bfd access to the general registers (.reg) and the
70    floating point registers (.reg2).  */
71
72const bfd_target *
73elf_core_file_p (bfd *abfd)
74{
75  Elf_External_Ehdr x_ehdr;	/* Elf file header, external form.  */
76  Elf_Internal_Ehdr *i_ehdrp;	/* Elf file header, internal form.  */
77  Elf_Internal_Phdr *i_phdrp;	/* Elf program header, internal form.  */
78  unsigned int phindex;
79  const struct elf_backend_data *ebd;
80  struct bfd_preserve preserve;
81  bfd_size_type amt;
82
83  preserve.marker = NULL;
84
85  /* Read in the ELF header in external format.  */
86  if (bfd_bread (&x_ehdr, sizeof (x_ehdr), abfd) != sizeof (x_ehdr))
87    {
88      if (bfd_get_error () != bfd_error_system_call)
89	goto wrong;
90      else
91	goto fail;
92    }
93
94  /* Check the magic number.  */
95  if (! elf_file_p (&x_ehdr))
96    goto wrong;
97
98  /* FIXME: Check EI_VERSION here !  */
99
100  /* Check the address size ("class").  */
101  if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
102    goto wrong;
103
104  /* Check the byteorder.  */
105  switch (x_ehdr.e_ident[EI_DATA])
106    {
107    case ELFDATA2MSB:		/* Big-endian.  */
108      if (! bfd_big_endian (abfd))
109	goto wrong;
110      break;
111    case ELFDATA2LSB:		/* Little-endian.  */
112      if (! bfd_little_endian (abfd))
113	goto wrong;
114      break;
115    default:
116      goto wrong;
117    }
118
119  if (!bfd_preserve_save (abfd, &preserve))
120    goto fail;
121
122  /* Give abfd an elf_obj_tdata.  */
123  if (! (*abfd->xvec->_bfd_set_format[bfd_core]) (abfd))
124    goto fail;
125  preserve.marker = elf_tdata (abfd);
126
127  /* Swap in the rest of the header, now that we have the byte order.  */
128  i_ehdrp = elf_elfheader (abfd);
129  elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
130
131#if DEBUG & 1
132  elf_debug_file (i_ehdrp);
133#endif
134
135  ebd = get_elf_backend_data (abfd);
136
137  /* Check that the ELF e_machine field matches what this particular
138     BFD format expects.  */
139
140  if (ebd->elf_machine_code != i_ehdrp->e_machine
141      && (ebd->elf_machine_alt1 == 0
142	  || i_ehdrp->e_machine != ebd->elf_machine_alt1)
143      && (ebd->elf_machine_alt2 == 0
144	  || i_ehdrp->e_machine != ebd->elf_machine_alt2))
145    {
146      const bfd_target * const *target_ptr;
147
148      if (ebd->elf_machine_code != EM_NONE)
149	goto wrong;
150
151      /* This is the generic ELF target.  Let it match any ELF target
152	 for which we do not have a specific backend.  */
153
154      for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
155	{
156	  const struct elf_backend_data *back;
157
158	  if ((*target_ptr)->flavour != bfd_target_elf_flavour)
159	    continue;
160	  back = (const struct elf_backend_data *) (*target_ptr)->backend_data;
161	  if (back->elf_machine_code == i_ehdrp->e_machine
162	      || (back->elf_machine_alt1 != 0
163	          && i_ehdrp->e_machine == back->elf_machine_alt1)
164	      || (back->elf_machine_alt2 != 0
165	          && i_ehdrp->e_machine == back->elf_machine_alt2))
166	    {
167	      /* target_ptr is an ELF backend which matches this
168		 object file, so reject the generic ELF target.  */
169	      goto wrong;
170	    }
171	}
172    }
173
174  /* If there is no program header, or the type is not a core file, then
175     we are hosed.  */
176  if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
177    goto wrong;
178
179  if (i_ehdrp->e_phnum == PN_XNUM)
180    {
181      Elf_External_Shdr x_shdr;	/* Section header table entry, external form */
182      Elf_Internal_Shdr i_shdr;	/* Section header table, internal form */
183      bfd_signed_vma where = i_ehdrp->e_shoff;
184
185      if (i_ehdrp->e_shoff == 0 || i_ehdrp->e_shnum < 1
186	  || i_ehdrp->e_shentsize != sizeof (x_shdr)
187	  || where != (file_ptr) where)
188	    goto wrong;
189
190      /* Seek to the section header table in the file.  */
191      if (bfd_seek (abfd, (file_ptr) where, SEEK_SET) != 0)
192        goto wrong;
193
194      /* Read the first section header at index 0, and convert to internal
195         form.  */
196      if (bfd_bread (&x_shdr, sizeof x_shdr, abfd) != sizeof (x_shdr))
197        goto wrong;
198      elf_swap_shdr_in (abfd, &x_shdr, &i_shdr);
199      i_ehdrp->e_phnum = i_shdr.sh_info;
200      if (i_ehdrp->e_phnum != i_shdr.sh_info)
201        goto wrong;
202    }
203
204  /* Does BFD's idea of the phdr size match the size
205     recorded in the file? */
206  if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
207    goto wrong;
208
209  /* Move to the start of the program headers.  */
210  if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
211    goto wrong;
212
213  /* Allocate space for the program headers.  */
214  amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
215  i_phdrp = bfd_alloc (abfd, amt);
216  if (!i_phdrp)
217    goto fail;
218
219  elf_tdata (abfd)->phdr = i_phdrp;
220
221  /* Read and convert to internal form.  */
222  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
223    {
224      Elf_External_Phdr x_phdr;
225
226      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
227	goto fail;
228
229      elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
230    }
231
232  /* Set the machine architecture.  Do this before processing the
233     program headers since we need to know the architecture type
234     when processing the notes of some systems' core files.  */
235  if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)
236      /* It's OK if this fails for the generic target.  */
237      && ebd->elf_machine_code != EM_NONE)
238    goto fail;
239
240  /* Let the backend double check the format and override global
241     information.  We do this before processing the program headers
242     to allow the correct machine (as opposed to just the default
243     machine) to be set, making it possible for grok_prstatus and
244     grok_psinfo to rely on the mach setting.  */
245  if (ebd->elf_backend_object_p != NULL
246      && ! ebd->elf_backend_object_p (abfd))
247    goto wrong;
248
249  /* Process each program header.  */
250  for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
251    if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
252      goto fail;
253
254  /* Save the entry point from the ELF header.  */
255  bfd_get_start_address (abfd) = i_ehdrp->e_entry;
256
257  bfd_preserve_finish (abfd, &preserve);
258  return abfd->xvec;
259
260wrong:
261  /* There is way too much undoing of half-known state here.  The caller,
262     bfd_check_format_matches, really shouldn't iterate on live bfd's to
263     check match/no-match like it does.  We have to rely on that a call to
264     bfd_default_set_arch_mach with the previously known mach, undoes what
265     was done by the first bfd_default_set_arch_mach (with mach 0) here.
266     For this to work, only elf-data and the mach may be changed by the
267     target-specific elf_backend_object_p function.  Note that saving the
268     whole bfd here and restoring it would be even worse; the first thing
269     you notice is that the cached bfd file position gets out of sync.  */
270  bfd_set_error (bfd_error_wrong_format);
271
272fail:
273  if (preserve.marker != NULL)
274    bfd_preserve_restore (abfd, &preserve);
275  return NULL;
276}
277