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 }