bfd/elfcore.h

   1 /* ELF core file support for BFD.
   2    Copyright 1995, 1996, 1997, 1998, 2000, 2001, 2002
   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
  52   corename = elf_tdata (core_bfd)->core_program;
  53   if (corename != NULL)
  54     {
  55       const char* execname = strrchr (exec_bfd->filename, '/');
  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  */
  77
  78 const bfd_target *
  79 elf_core_file_p (abfd)
  80      bfd *abfd;
  81 {
  82   Elf_External_Ehdr x_ehdr;     /* Elf file header, external form */
  83   Elf_Internal_Ehdr *i_ehdrp;   /* Elf file header, internal form */
  84   Elf_Internal_Phdr *i_phdrp;   /* Elf program header, internal form */
  85   unsigned int phindex;
  86   struct elf_backend_data *ebd;
  87   struct bfd_preserve preserve;
  88   bfd_size_type amt;
  89
  90   preserve.marker = NULL;
  91
  92   /* Read in the ELF header in external format.  */
  93   if (bfd_bread ((PTR) &x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
  94       != sizeof (x_ehdr))
  95     {
  96       if (bfd_get_error () != bfd_error_system_call)
  97         goto wrong;
  98       else
  99         goto fail;
 100     }
 101
 102   /* Check the magic number.  */
 103   if (! elf_file_p (&x_ehdr))
 104     goto wrong;
 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   amt = sizeof (struct elf_obj_tdata);
 129   preserve.marker = bfd_zalloc (abfd, amt);
 130   if (preserve.marker == NULL)
 131     goto fail;
 132   if (!bfd_preserve_save (abfd, &preserve))
 133     goto fail;
 134
 135   elf_tdata (abfd) = preserve.marker;
 136
 137   /* Swap in the rest of the header, now that we have the byte order.  */
 138   i_ehdrp = elf_elfheader (abfd);
 139   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 140
 141 #if DEBUG & 1
 142   elf_debug_file (i_ehdrp);
 143 #endif
 144
 145   ebd = get_elf_backend_data (abfd);
 146
 147   /* Check that the ELF e_machine field matches what this particular
 148      BFD format expects.  */
 149
 150   if (ebd->elf_machine_code != i_ehdrp->e_machine
 151       && (ebd->elf_machine_alt1 == 0
 152           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 153       && (ebd->elf_machine_alt2 == 0
 154           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 155     {
 156       const bfd_target * const *target_ptr;
 157
 158       if (ebd->elf_machine_code != EM_NONE)
 159         goto wrong;
 160
 161       /* This is the generic ELF target.  Let it match any ELF target
 162          for which we do not have a specific backend.  */
 163
 164       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 165         {
 166           struct elf_backend_data *back;
 167
 168           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 169             continue;
 170           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 171           if (back->elf_machine_code == i_ehdrp->e_machine)
 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       if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof (x_phdr), abfd)
 207           != sizeof (x_phdr))
 208         goto fail;
 209
 210       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 211     }
 212
 213   /* Set the machine architecture.  Do this before processing the
 214      program headers since we need to know the architecture type
 215      when processing the notes of some systems' core files.  */
 216   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 217     {
 218       /* It's OK if this fails for the generic target.  */
 219       if (ebd->elf_machine_code != EM_NONE)
 220         goto fail;
 221     }
 222
 223   /* Process each program header.  */
 224   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 225     {
 226       if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
 227         goto fail;
 228     }
 229
 230   /* Save the entry point from the ELF header.  */
 231   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 232
 233   /* Let the backend double check the format and override global
 234      information.  */
 235   if (ebd->elf_backend_object_p)
 236     {
 237       if (! (*ebd->elf_backend_object_p) (abfd))
 238         goto wrong;
 239     }
 240
 241   bfd_preserve_finish (abfd, &preserve);
 242   return abfd->xvec;
 243
 244 wrong:
 245   /* There is way too much undoing of half-known state here.  The caller,
 246      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 247      check match/no-match like it does.  We have to rely on that a call to
 248      bfd_default_set_arch_mach with the previously known mach, undoes what
 249      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 250      For this to work, only elf-data and the mach may be changed by the
 251      target-specific elf_backend_object_p function.  Note that saving the
 252      whole bfd here and restoring it would be even worse; the first thing
 253      you notice is that the cached bfd file position gets out of sync.  */
 254   bfd_set_error (bfd_error_wrong_format);
 255
 256 fail:
 257   if (preserve.marker != NULL)
 258     bfd_preserve_restore (abfd, &preserve);
 259   return NULL;
 260 }