bfd/elfcore.h

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 char*
  22 elf_core_file_failing_command (bfd *abfd)
  23 {
  24   return elf_tdata (abfd)->core_command;
  25 }
  26
  27 int
  28 elf_core_file_failing_signal (bfd *abfd)
  29 {
  30   return elf_tdata (abfd)->core_signal;
  31 }
  32
  33 bfd_boolean
  34 elf_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
  72 const bfd_target *
  73 elf_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   /* Does BFD's idea of the phdr size match the size
 180      recorded in the file? */
 181   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 182     goto wrong;
 183
 184   /* Move to the start of the program headers.  */
 185   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 186     goto wrong;
 187
 188   /* Allocate space for the program headers.  */
 189   amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
 190   i_phdrp = bfd_alloc (abfd, amt);
 191   if (!i_phdrp)
 192     goto fail;
 193
 194   elf_tdata (abfd)->phdr = i_phdrp;
 195
 196   /* Read and convert to internal form.  */
 197   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 198     {
 199       Elf_External_Phdr x_phdr;
 200
 201       if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
 202         goto fail;
 203
 204       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 205     }
 206
 207   /* Set the machine architecture.  Do this before processing the
 208      program headers since we need to know the architecture type
 209      when processing the notes of some systems' core files.  */
 210   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0)
 211       /* It's OK if this fails for the generic target.  */
 212       && ebd->elf_machine_code != EM_NONE)
 213     goto fail;
 214
 215   /* Let the backend double check the format and override global
 216      information.  We do this before processing the program headers
 217      to allow the correct machine (as opposed to just the default
 218      machine) to be set, making it possible for grok_prstatus and
 219      grok_psinfo to rely on the mach setting.  */
 220   if (ebd->elf_backend_object_p != NULL
 221       && ! ebd->elf_backend_object_p (abfd))
 222     goto wrong;
 223
 224   /* Process each program header.  */
 225   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 226     if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
 227       goto fail;
 228
 229   /* Save the entry point from the ELF header.  */
 230   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 231
 232   bfd_preserve_finish (abfd, &preserve);
 233   return abfd->xvec;
 234
 235 wrong:
 236   /* There is way too much undoing of half-known state here.  The caller,
 237      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 238      check match/no-match like it does.  We have to rely on that a call to
 239      bfd_default_set_arch_mach with the previously known mach, undoes what
 240      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 241      For this to work, only elf-data and the mach may be changed by the
 242      target-specific elf_backend_object_p function.  Note that saving the
 243      whole bfd here and restoring it would be even worse; the first thing
 244      you notice is that the cached bfd file position gets out of sync.  */
 245   bfd_set_error (bfd_error_wrong_format);
 246
 247 fail:
 248   if (preserve.marker != NULL)
 249     bfd_preserve_restore (abfd, &preserve);
 250   return NULL;
 251 }