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 char*
  21 elf_core_file_failing_command (abfd)
  22      bfd *abfd;
  23 {
  24   return elf_tdata (abfd)->core_command;
  25 }
  26
  27 int
  28 elf_core_file_failing_signal (abfd)
  29      bfd *abfd;
  30 {
  31   return elf_tdata (abfd)->core_signal;
  32 }
  33
  34 boolean
  35 elf_core_file_matches_executable_p (core_bfd, exec_bfd)
  36      bfd *core_bfd;
  37      bfd *exec_bfd;
  38 {
  39   char* corename;
  40
  41   /* xvecs must match if both are ELF files for the same target.  */
  42
  43   if (core_bfd->xvec != exec_bfd->xvec)
  44     {
  45       bfd_set_error (bfd_error_system_call);
  46       return false;
  47     }
  48
  49   /* See if the name in the corefile matches the executable name.  */
  50
  51   corename = elf_tdata (core_bfd)->core_program;
  52   if (corename != NULL)
  53     {
  54       const char* execname = strrchr (exec_bfd->filename, '/');
  55       execname = execname ? execname + 1 : exec_bfd->filename;
  56
  57       if (strcmp(execname, corename) != 0)
  58         return false;
  59     }
  60
  61   return true;
  62 }
  63
  64 /*  Core files are simply standard ELF formatted files that partition
  65     the file using the execution view of the file (program header table)
  66     rather than the linking view.  In fact, there is no section header
  67     table in a core file.
  68
  69     The process status information (including the contents of the general
  70     register set) and the floating point register set are stored in a
  71     segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
  72     that allow standard bfd access to the general registers (.reg) and the
  73     floating point registers (.reg2).
  74
  75  */
  76
  77 const bfd_target *
  78 elf_core_file_p (abfd)
  79      bfd *abfd;
  80 {
  81   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
  82   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
  83   Elf_Internal_Phdr *i_phdrp = NULL;    /* Elf program header, internal form */
  84   unsigned int phindex;
  85   struct elf_backend_data *ebd;
  86   struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
  87   struct elf_obj_tdata *new_tdata = NULL;
  88
  89   /* Read in the ELF header in external format.  */
  90   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
  91     {
  92       if (bfd_get_error () != bfd_error_system_call)
  93         bfd_set_error (bfd_error_wrong_format);
  94       return NULL;
  95     }
  96
  97   /* Check the magic number.  */
  98   if (elf_file_p (&x_ehdr) == false)
  99     goto wrong;
 100
 101   /* FIXME: Check EI_VERSION here ! */
 102
 103   /* Check the address size ("class").  */
 104   if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 105     goto wrong;
 106
 107   /* Check the byteorder.  */
 108   switch (x_ehdr.e_ident[EI_DATA])
 109     {
 110     case ELFDATA2MSB:           /* Big-endian */
 111       if (! bfd_big_endian (abfd))
 112         goto wrong;
 113       break;
 114     case ELFDATA2LSB:           /* Little-endian */
 115       if (! bfd_little_endian (abfd))
 116         goto wrong;
 117       break;
 118     default:
 119       goto wrong;
 120     }
 121
 122   /* Give abfd an elf_obj_tdata.  */
 123   new_tdata =
 124     (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
 125   if (new_tdata == NULL)
 126     return NULL;
 127   elf_tdata (abfd) = new_tdata;
 128
 129   /* Swap in the rest of the header, now that we have the byte order.  */
 130   i_ehdrp = elf_elfheader (abfd);
 131   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 132
 133 #if DEBUG & 1
 134   elf_debug_file (i_ehdrp);
 135 #endif
 136
 137   ebd = get_elf_backend_data (abfd);
 138
 139   /* Check that the ELF e_machine field matches what this particular
 140      BFD format expects.  */
 141
 142   if (ebd->elf_machine_code != i_ehdrp->e_machine
 143       && (ebd->elf_machine_alt1 == 0
 144           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 145       && (ebd->elf_machine_alt2 == 0
 146           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 147     {
 148       const bfd_target * const *target_ptr;
 149
 150       if (ebd->elf_machine_code != EM_NONE)
 151         goto wrong;
 152
 153       /* This is the generic ELF target.  Let it match any ELF target
 154          for which we do not have a specific backend.  */
 155
 156       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 157         {
 158           struct elf_backend_data *back;
 159
 160           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 161             continue;
 162           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 163           if (back->elf_machine_code == i_ehdrp->e_machine)
 164             {
 165               /* target_ptr is an ELF backend which matches this
 166                  object file, so reject the generic ELF target.  */
 167               goto wrong;
 168             }
 169         }
 170     }
 171
 172   /* If there is no program header, or the type is not a core file, then
 173      we are hosed.  */
 174   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 175     goto wrong;
 176
 177   /* Does BFD's idea of the phdr size match the size
 178      recorded in the file? */
 179   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 180     goto wrong;
 181
 182   /* Move to the start of the program headers.  */
 183   if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0)
 184     goto wrong;
 185
 186   /* Allocate space for the program headers.  */
 187   i_phdrp = (Elf_Internal_Phdr *)
 188     bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
 189   if (!i_phdrp)
 190     goto fail;
 191
 192   elf_tdata (abfd)->phdr = i_phdrp;
 193
 194   /* Read and convert to internal form.  */
 195   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 196     {
 197       Elf_External_Phdr x_phdr;
 198       if (bfd_read ((PTR) &x_phdr, sizeof (x_phdr), 1, abfd)
 199           != sizeof (x_phdr))
 200         goto fail;
 201
 202       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 203     }
 204
 205   /* Process each program header.  */
 206   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 207     {
 208       if (!_bfd_elfcore_section_from_phdr (abfd, i_phdrp + phindex, phindex))
 209         goto fail;
 210     }
 211
 212   /* Set the machine architecture.  */
 213   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 214     {
 215       /* It's OK if this fails for the generic target.  */
 216       if (ebd->elf_machine_code != EM_NONE)
 217         goto fail;
 218     }
 219
 220   /* Save the entry point from the ELF header.  */
 221   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 222
 223   /* Let the backend double check the format and override global
 224      information.  */
 225   if (ebd->elf_backend_object_p)
 226     {
 227       if ((*ebd->elf_backend_object_p) (abfd) == false)
 228         goto wrong;
 229     }
 230
 231   return abfd->xvec;
 232
 233 wrong:
 234   bfd_set_error (bfd_error_wrong_format);
 235 fail:
 236   if (i_phdrp != NULL)
 237     bfd_release (abfd, i_phdrp);
 238   if (new_tdata != NULL)
 239     bfd_release (abfd, new_tdata);
 240   elf_tdata (abfd) = preserved_tdata;
 241   return NULL;
 242 }