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     {
 103       goto wrong;
 104     }
 105
 106   /* FIXME: Check EI_VERSION here ! */
 107
 108   /* Check the address size ("class"). */
 109   if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 110     goto wrong;
 111
 112   /* Check the byteorder. */
 113   switch (x_ehdr.e_ident[EI_DATA])
 114     {
 115     case ELFDATA2MSB:           /* Big-endian */
 116       if (! bfd_big_endian (abfd))
 117         goto wrong;
 118       break;
 119     case ELFDATA2LSB:           /* Little-endian */
 120       if (! bfd_little_endian (abfd))
 121         goto wrong;
 122       break;
 123     default:
 124       goto wrong;
 125     }
 126
 127   /* Give abfd an elf_obj_tdata. */
 128   new_tdata =
 129     (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
 130   if (new_tdata == NULL)
 131     return NULL;
 132   elf_tdata (abfd) = new_tdata;
 133
 134   /* Swap in the rest of the header, now that we have the byte order. */
 135   i_ehdrp = elf_elfheader (abfd);
 136   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 137
 138 #if DEBUG & 1
 139   elf_debug_file (i_ehdrp);
 140 #endif
 141
 142   ebd = get_elf_backend_data (abfd);
 143
 144   /* Check that the ELF e_machine field matches what this particular
 145      BFD format expects.  */
 146
 147   if (ebd->elf_machine_code != i_ehdrp->e_machine
 148       && (ebd->elf_machine_alt1 == 0
 149           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 150       && (ebd->elf_machine_alt2 == 0
 151           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 152     {
 153       const bfd_target * const *target_ptr;
 154
 155       if (ebd->elf_machine_code != EM_NONE)
 156         goto wrong;
 157
 158       /* This is the generic ELF target.  Let it match any ELF target
 159          for which we do not have a specific backend.  */
 160
 161       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 162         {
 163           struct elf_backend_data *back;
 164
 165           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 166             continue;
 167           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 168           if (back->elf_machine_code == i_ehdrp->e_machine)
 169             {
 170               /* target_ptr is an ELF backend which matches this
 171                  object file, so reject the generic ELF target.  */
 172               goto wrong;
 173             }
 174         }
 175     }
 176
 177   /* If there is no program header, or the type is not a core file, then
 178      we are hosed. */
 179   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 180     goto wrong;
 181
 182   /* Does BFD's idea of the phdr size match the size
 183      recorded in the file? */
 184   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 185     goto wrong;
 186
 187   /* Allocate space for the program headers. */
 188   i_phdrp = (Elf_Internal_Phdr *)
 189     bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
 190   if (!i_phdrp)
 191     goto fail;
 192
 193   elf_tdata (abfd)->phdr = i_phdrp;
 194
 195   /* Read and convert to internal form. */
 196   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 197     {
 198       Elf_External_Phdr x_phdr;
 199       if (bfd_read ((PTR) &x_phdr, sizeof (x_phdr), 1, abfd)
 200           != sizeof (x_phdr))
 201         goto fail;
 202
 203       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 204     }
 205
 206   /* Process each program header. */
 207   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 208     {
 209       if (!_bfd_elfcore_section_from_phdr (abfd, i_phdrp + phindex, phindex))
 210         goto fail;
 211     }
 212
 213   /* Set the machine architecture. */
 214   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 215     {
 216       /* It's OK if this fails for the generic target.  */
 217       if (ebd->elf_machine_code != EM_NONE)
 218         goto fail;
 219     }
 220
 221   /* Save the entry point from the ELF header. */
 222   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 223
 224   /* Let the backend double check the format and override global
 225      information.  */
 226   if (ebd->elf_backend_object_p)
 227     {
 228       if ((*ebd->elf_backend_object_p) (abfd) == false)
 229         goto wrong;
 230     }
 231
 232   return abfd->xvec;
 233
 234 wrong:
 235   bfd_set_error (bfd_error_wrong_format);
 236 fail:
 237   if (i_phdrp != NULL)
 238     bfd_release (abfd, i_phdrp);
 239   if (new_tdata != NULL)
 240     bfd_release (abfd, new_tdata);
 241   elf_tdata (abfd) = preserved_tdata;
 242   return NULL;
 243 }