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   /* Give abfd an elf_obj_tdata.  */
 126   amt = sizeof (struct elf_obj_tdata);
 127   preserve.marker = bfd_zalloc (abfd, amt);
 128   if (preserve.marker == NULL)
 129     goto fail;
 130   if (!bfd_preserve_save (abfd, &preserve))
 131     goto fail;
 132
 133   elf_tdata (abfd) = preserve.marker;
 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               || (back->elf_machine_alt1 != 0
 171                   && i_ehdrp->e_machine == back->elf_machine_alt1)
 172               || (back->elf_machine_alt2 != 0
 173                   && i_ehdrp->e_machine == back->elf_machine_alt2))
 174             {
 175               /* target_ptr is an ELF backend which matches this
 176                  object file, so reject the generic ELF target.  */
 177               goto wrong;
 178             }
 179         }
 180     }
 181
 182   /* If there is no program header, or the type is not a core file, then
 183      we are hosed.  */
 184   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 185     goto wrong;
 186
 187   /* Does BFD's idea of the phdr size match the size
 188      recorded in the file? */
 189   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 190     goto wrong;
 191
 192   /* Move to the start of the program headers.  */
 193   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 194     goto wrong;
 195
 196   /* Allocate space for the program headers.  */
 197   amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
 198   i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
 199   if (!i_phdrp)
 200     goto fail;
 201
 202   elf_tdata (abfd)->phdr = i_phdrp;
 203
 204   /* Read and convert to internal form.  */
 205   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 206     {
 207       Elf_External_Phdr x_phdr;
 208
 209       if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof (x_phdr), abfd)
 210           != sizeof (x_phdr))
 211         goto fail;
 212
 213       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 214     }
 215
 216   /* Set the machine architecture.  Do this before processing the
 217      program headers since we need to know the architecture type
 218      when processing the notes of some systems' core files.  */
 219   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 220     {
 221       /* It's OK if this fails for the generic target.  */
 222       if (ebd->elf_machine_code != EM_NONE)
 223         goto fail;
 224     }
 225
 226   /* Process each program header.  */
 227   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 228     if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
 229       goto fail;
 230
 231   /* Save the entry point from the ELF header.  */
 232   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 233
 234   /* Let the backend double check the format and override global
 235      information.  */
 236   if (ebd->elf_backend_object_p
 237       && (! (*ebd->elf_backend_object_p) (abfd)))
 238     goto wrong;
 239
 240   bfd_preserve_finish (abfd, &preserve);
 241   return abfd->xvec;
 242
 243 wrong:
 244   /* There is way too much undoing of half-known state here.  The caller,
 245      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 246      check match/no-match like it does.  We have to rely on that a call to
 247      bfd_default_set_arch_mach with the previously known mach, undoes what
 248      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 249      For this to work, only elf-data and the mach may be changed by the
 250      target-specific elf_backend_object_p function.  Note that saving the
 251      whole bfd here and restoring it would be even worse; the first thing
 252      you notice is that the cached bfd file position gets out of sync.  */
 253   bfd_set_error (bfd_error_wrong_format);
 254
 255 fail:
 256   if (preserve.marker != NULL)
 257     bfd_preserve_restore (abfd, &preserve);
 258   return NULL;
 259 }