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;   /* Elf program header, internal form */
  87   unsigned int phindex;
  88   struct elf_backend_data *ebd;
  89
  90   /* Read in the ELF header in external format.  */
  91   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
  92     {
  93       if (bfd_get_error () != bfd_error_system_call)
  94         bfd_set_error (bfd_error_wrong_format);
  95       return NULL;
  96     }
  97
  98   /* Check the magic number. */
  99   if (elf_file_p (&x_ehdr) == false)
 100     {
 101     wrong:
 102       bfd_set_error (bfd_error_wrong_format);
 103       return NULL;
 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   elf_tdata (abfd) =
 129     (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
 130   if (elf_tdata (abfd) == NULL)
 131     return NULL;
 132
 133   /* FIXME: from here on down, "goto wrong" will leak memory.  */
 134
 135   /* Swap in the rest of the header, now that we have the byte order. */
 136   i_ehdrp = elf_elfheader (abfd);
 137   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 138
 139 #if DEBUG & 1
 140   elf_debug_file (i_ehdrp);
 141 #endif
 142
 143   ebd = get_elf_backend_data (abfd);
 144
 145   /* Check that the ELF e_machine field matches what this particular
 146      BFD format expects.  */
 147
 148   if (ebd->elf_machine_code != i_ehdrp->e_machine
 149       && (ebd->elf_machine_alt1 == 0
 150           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 151       && (ebd->elf_machine_alt2 == 0
 152           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 153     {
 154       const bfd_target * const *target_ptr;
 155
 156       if (ebd->elf_machine_code != EM_NONE)
 157         goto wrong;
 158
 159       /* This is the generic ELF target.  Let it match any ELF target
 160          for which we do not have a specific backend.  */
 161
 162       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 163         {
 164           struct elf_backend_data *back;
 165
 166           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 167             continue;
 168           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 169           if (back->elf_machine_code == i_ehdrp->e_machine)
 170             {
 171               /* target_ptr is an ELF backend which matches this
 172                  object file, so reject the generic ELF target.  */
 173               goto wrong;
 174             }
 175         }
 176     }
 177
 178   /* If there is no program header, or the type is not a core file, then
 179      we are hosed. */
 180   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 181     goto wrong;
 182
 183   /* Does BFD's idea of the phdr size match the size
 184      recorded in the file? */
 185   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 186     goto wrong;
 187
 188   /* Allocate space for the program headers. */
 189   i_phdrp = (Elf_Internal_Phdr *)
 190     bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
 191   if (!i_phdrp)
 192     return NULL;
 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       if (bfd_read ((PTR) &x_phdr, sizeof (x_phdr), 1, abfd)
 201           != sizeof (x_phdr))
 202         return NULL;
 203
 204       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 205     }
 206
 207   /* Process each program header. */
 208   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 209     {
 210       if (!_bfd_elfcore_section_from_phdr (abfd, i_phdrp + phindex, phindex))
 211         return NULL;
 212     }
 213
 214   /* Set the machine architecture. */
 215   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 216     {
 217       /* It's OK if this fails for the generic target.  */
 218       if (ebd->elf_machine_code != EM_NONE)
 219         return NULL;
 220     }
 221
 222   /* Save the entry point from the ELF header. */
 223   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 224
 225   return abfd->xvec;
 226 }