bfd/elfcore.h

   1 /* ELF core file support for BFD.
   2    Copyright 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003
   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 (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 bfd_boolean
  36 elf_core_file_matches_executable_p (core_bfd, exec_bfd)
  37      bfd *core_bfd;
  38      bfd *exec_bfd;
  39 {
  40   char* corename;
  41
  42   /* xvecs must match if both are ELF files for the same target.  */
  43
  44   if (core_bfd->xvec != exec_bfd->xvec)
  45     {
  46       bfd_set_error (bfd_error_system_call);
  47       return FALSE;
  48     }
  49
  50   /* See if the name in the corefile matches the executable name.  */
  51   corename = elf_tdata (core_bfd)->core_program;
  52   if (corename != NULL)
  53     {
  54       const char* execname = strrchr (exec_bfd->filename, '/');
  55
  56       execname = execname ? execname + 1 : exec_bfd->filename;
  57
  58       if (strcmp(execname, corename) != 0)
  59         return FALSE;
  60     }
  61
  62   return TRUE;
  63 }
  64
  65 /*  Core files are simply standard ELF formatted files that partition
  66     the file using the execution view of the file (program header table)
  67     rather than the linking view.  In fact, there is no section header
  68     table in a core file.
  69
  70     The process status information (including the contents of the general
  71     register set) and the floating point register set are stored in a
  72     segment of type PT_NOTE.  We handcraft a couple of extra bfd sections
  73     that allow standard bfd access to the general registers (.reg) and the
  74     floating point registers (.reg2).  */
  75
  76 const bfd_target *
  77 elf_core_file_p (abfd)
  78      bfd *abfd;
  79 {
  80   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form.  */
  81   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form.  */
  82   Elf_Internal_Phdr *i_phdrp;   /* Elf program header, internal form.  */
  83   unsigned int phindex;
  84   struct elf_backend_data *ebd;
  85   struct bfd_preserve preserve;
  86   bfd_size_type amt;
  87
  88   preserve.marker = NULL;
  89
  90   /* Read in the ELF header in external format.  */
  91   if (bfd_bread ((PTR) &x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
  92       != sizeof (x_ehdr))
  93     {
  94       if (bfd_get_error () != bfd_error_system_call)
  95         goto wrong;
  96       else
  97         goto fail;
  98     }
  99
 100   /* Check the magic number.  */
 101   if (! elf_file_p (&x_ehdr))
 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   if (!bfd_preserve_save (abfd, &preserve))
 126     goto fail;
 127
 128   /* Give abfd an elf_obj_tdata.  */
 129   if (! (*abfd->xvec->_bfd_set_format[bfd_core]) (abfd))
 130     goto fail;
 131   preserve.marker = elf_tdata (abfd);
 132
 133   /* Swap in the rest of the header, now that we have the byte order.  */
 134   i_ehdrp = elf_elfheader (abfd);
 135   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 136
 137 #if DEBUG & 1
 138   elf_debug_file (i_ehdrp);
 139 #endif
 140
 141   ebd = get_elf_backend_data (abfd);
 142
 143   /* Check that the ELF e_machine field matches what this particular
 144      BFD format expects.  */
 145
 146   if (ebd->elf_machine_code != i_ehdrp->e_machine
 147       && (ebd->elf_machine_alt1 == 0
 148           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 149       && (ebd->elf_machine_alt2 == 0
 150           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 151     {
 152       const bfd_target * const *target_ptr;
 153
 154       if (ebd->elf_machine_code != EM_NONE)
 155         goto wrong;
 156
 157       /* This is the generic ELF target.  Let it match any ELF target
 158          for which we do not have a specific backend.  */
 159
 160       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 161         {
 162           struct elf_backend_data *back;
 163
 164           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 165             continue;
 166           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 167           if (back->elf_machine_code == i_ehdrp->e_machine
 168               || (back->elf_machine_alt1 != 0
 169                   && i_ehdrp->e_machine == back->elf_machine_alt1)
 170               || (back->elf_machine_alt2 != 0
 171                   && i_ehdrp->e_machine == back->elf_machine_alt2))
 172             {
 173               /* target_ptr is an ELF backend which matches this
 174                  object file, so reject the generic ELF target.  */
 175               goto wrong;
 176             }
 177         }
 178     }
 179
 180   /* If there is no program header, or the type is not a core file, then
 181      we are hosed.  */
 182   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 183     goto wrong;
 184
 185   /* Does BFD's idea of the phdr size match the size
 186      recorded in the file? */
 187   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 188     goto wrong;
 189
 190   /* Move to the start of the program headers.  */
 191   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 192     goto wrong;
 193
 194   /* Allocate space for the program headers.  */
 195   amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
 196   i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
 197   if (!i_phdrp)
 198     goto fail;
 199
 200   elf_tdata (abfd)->phdr = i_phdrp;
 201
 202   /* Read and convert to internal form.  */
 203   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 204     {
 205       Elf_External_Phdr x_phdr;
 206
 207       if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof (x_phdr), abfd)
 208           != sizeof (x_phdr))
 209         goto fail;
 210
 211       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 212     }
 213
 214   /* Set the machine architecture.  Do this before processing the
 215      program headers since we need to know the architecture type
 216      when processing the notes of some systems' core files.  */
 217   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 218     {
 219       /* It's OK if this fails for the generic target.  */
 220       if (ebd->elf_machine_code != EM_NONE)
 221         goto fail;
 222     }
 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   /* Let the backend double check the format and override global
 233      information.  */
 234   if (ebd->elf_backend_object_p
 235       && (! (*ebd->elf_backend_object_p) (abfd)))
 236     goto wrong;
 237
 238   bfd_preserve_finish (abfd, &preserve);
 239   return abfd->xvec;
 240
 241 wrong:
 242   /* There is way too much undoing of half-known state here.  The caller,
 243      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 244      check match/no-match like it does.  We have to rely on that a call to
 245      bfd_default_set_arch_mach with the previously known mach, undoes what
 246      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 247      For this to work, only elf-data and the mach may be changed by the
 248      target-specific elf_backend_object_p function.  Note that saving the
 249      whole bfd here and restoring it would be even worse; the first thing
 250      you notice is that the cached bfd file position gets out of sync.  */
 251   bfd_set_error (bfd_error_wrong_format);
 252
 253 fail:
 254   if (preserve.marker != NULL)
 255     bfd_preserve_restore (abfd, &preserve);
 256   return NULL;
 257 }