bfd/elfcore.h

   1 /* ELF core file support for BFD.
   2    Copyright 1995, 1996, 1997, 1998, 2000, 2001
   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 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 = NULL;    /* Elf program header, internal form */
  85   unsigned int phindex;
  86   struct elf_backend_data *ebd;
  87   struct elf_obj_tdata *preserved_tdata = elf_tdata (abfd);
  88   struct sec *preserved_sections = abfd->sections;
  89   unsigned int preserved_section_count = abfd->section_count;
  90   enum bfd_architecture previous_arch = bfd_get_arch (abfd);
  91   unsigned long previous_mach = bfd_get_mach (abfd);
  92   struct elf_obj_tdata *new_tdata = NULL;
  93   bfd_size_type amt;
  94
  95   /* Clear section information, since there might be a recognized bfd that
  96      we now check if we can replace, and we don't want to append to it.  */
  97   abfd->sections = NULL;
  98   abfd->section_count = 0;
  99
 100   /* Read in the ELF header in external format.  */
 101   if (bfd_bread ((PTR) &x_ehdr, (bfd_size_type) sizeof (x_ehdr), abfd)
 102       != sizeof (x_ehdr))
 103     {
 104       if (bfd_get_error () != bfd_error_system_call)
 105         bfd_set_error (bfd_error_wrong_format);
 106       return NULL;
 107     }
 108
 109   /* Check the magic number.  */
 110   if (elf_file_p (&x_ehdr) == false)
 111     goto wrong;
 112
 113   /* FIXME: Check EI_VERSION here ! */
 114
 115   /* Check the address size ("class").  */
 116   if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 117     goto wrong;
 118
 119   /* Check the byteorder.  */
 120   switch (x_ehdr.e_ident[EI_DATA])
 121     {
 122     case ELFDATA2MSB:           /* Big-endian */
 123       if (! bfd_big_endian (abfd))
 124         goto wrong;
 125       break;
 126     case ELFDATA2LSB:           /* Little-endian */
 127       if (! bfd_little_endian (abfd))
 128         goto wrong;
 129       break;
 130     default:
 131       goto wrong;
 132     }
 133
 134   /* Give abfd an elf_obj_tdata.  */
 135   amt = sizeof (struct elf_obj_tdata);
 136   new_tdata = (struct elf_obj_tdata *) bfd_zalloc (abfd, amt);
 137   if (new_tdata == NULL)
 138     return NULL;
 139   elf_tdata (abfd) = new_tdata;
 140
 141   /* Swap in the rest of the header, now that we have the byte order.  */
 142   i_ehdrp = elf_elfheader (abfd);
 143   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 144
 145 #if DEBUG & 1
 146   elf_debug_file (i_ehdrp);
 147 #endif
 148
 149   ebd = get_elf_backend_data (abfd);
 150
 151   /* Check that the ELF e_machine field matches what this particular
 152      BFD format expects.  */
 153
 154   if (ebd->elf_machine_code != i_ehdrp->e_machine
 155       && (ebd->elf_machine_alt1 == 0
 156           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 157       && (ebd->elf_machine_alt2 == 0
 158           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 159     {
 160       const bfd_target * const *target_ptr;
 161
 162       if (ebd->elf_machine_code != EM_NONE)
 163         goto wrong;
 164
 165       /* This is the generic ELF target.  Let it match any ELF target
 166          for which we do not have a specific backend.  */
 167
 168       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 169         {
 170           struct elf_backend_data *back;
 171
 172           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 173             continue;
 174           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 175           if (back->elf_machine_code == i_ehdrp->e_machine)
 176             {
 177               /* target_ptr is an ELF backend which matches this
 178                  object file, so reject the generic ELF target.  */
 179               goto wrong;
 180             }
 181         }
 182     }
 183
 184   /* If there is no program header, or the type is not a core file, then
 185      we are hosed.  */
 186   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 187     goto wrong;
 188
 189   /* Does BFD's idea of the phdr size match the size
 190      recorded in the file? */
 191   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 192     goto wrong;
 193
 194   /* Move to the start of the program headers.  */
 195   if (bfd_seek (abfd, (file_ptr) i_ehdrp->e_phoff, SEEK_SET) != 0)
 196     goto wrong;
 197
 198   /* Allocate space for the program headers.  */
 199   amt = sizeof (*i_phdrp) * i_ehdrp->e_phnum;
 200   i_phdrp = (Elf_Internal_Phdr *) bfd_alloc (abfd, amt);
 201   if (!i_phdrp)
 202     goto fail;
 203
 204   elf_tdata (abfd)->phdr = i_phdrp;
 205
 206   /* Read and convert to internal form.  */
 207   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 208     {
 209       Elf_External_Phdr x_phdr;
 210       if (bfd_bread ((PTR) &x_phdr, (bfd_size_type) sizeof (x_phdr), abfd)
 211           != sizeof (x_phdr))
 212         goto fail;
 213
 214       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 215     }
 216
 217   /* Process each program header.  */
 218   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 219     {
 220       if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, (int) phindex))
 221         goto fail;
 222     }
 223
 224   /* Set the machine architecture.  */
 225   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 226     {
 227       /* It's OK if this fails for the generic target.  */
 228       if (ebd->elf_machine_code != EM_NONE)
 229         goto fail;
 230     }
 231
 232   /* Save the entry point from the ELF header.  */
 233   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 234
 235   /* Let the backend double check the format and override global
 236      information.  */
 237   if (ebd->elf_backend_object_p)
 238     {
 239       if ((*ebd->elf_backend_object_p) (abfd) == false)
 240         goto wrong;
 241     }
 242
 243   return abfd->xvec;
 244
 245 wrong:
 246   /* There is way too much undoing of half-known state here.  The caller,
 247      bfd_check_format_matches, really shouldn't iterate on live bfd's to
 248      check match/no-match like it does.  We have to rely on that a call to
 249      bfd_default_set_arch_mach with the previously known mach, undoes what
 250      was done by the first bfd_default_set_arch_mach (with mach 0) here.
 251      For this to work, only elf-data and the mach may be changed by the
 252      target-specific elf_backend_object_p function.  Note that saving the
 253      whole bfd here and restoring it would be even worse; the first thing
 254      you notice is that the cached bfd file position gets out of sync.  */
 255   bfd_default_set_arch_mach (abfd, previous_arch, previous_mach);
 256   bfd_set_error (bfd_error_wrong_format);
 257 fail:
 258   if (i_phdrp != NULL)
 259     bfd_release (abfd, i_phdrp);
 260   if (new_tdata != NULL)
 261     bfd_release (abfd, new_tdata);
 262   elf_tdata (abfd) = preserved_tdata;
 263   abfd->sections = preserved_sections;
 264   abfd->section_count = preserved_section_count;
 265   return NULL;
 266 }