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 elf_obj_tdata *new_tdata = NULL;
  89
  90   /* Read in the ELF header in external format.  */
  91   if (bfd_read ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd) != sizeof (x_ehdr))
  92     {
  93       if (bfd_get_error () != bfd_error_system_call)
  94         bfd_set_error (bfd_error_wrong_format);
  95       return NULL;
  96     }
  97
  98   /* Check the magic number.  */
  99   if (elf_file_p (&x_ehdr) == false)
 100     goto wrong;
 101
 102   /* FIXME: Check EI_VERSION here ! */
 103
 104   /* Check the address size ("class").  */
 105   if (x_ehdr.e_ident[EI_CLASS] != ELFCLASS)
 106     goto wrong;
 107
 108   /* Check the byteorder.  */
 109   switch (x_ehdr.e_ident[EI_DATA])
 110     {
 111     case ELFDATA2MSB:           /* Big-endian */
 112       if (! bfd_big_endian (abfd))
 113         goto wrong;
 114       break;
 115     case ELFDATA2LSB:           /* Little-endian */
 116       if (! bfd_little_endian (abfd))
 117         goto wrong;
 118       break;
 119     default:
 120       goto wrong;
 121     }
 122
 123   /* Give abfd an elf_obj_tdata.  */
 124   new_tdata =
 125     (struct elf_obj_tdata *) bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
 126   if (new_tdata == NULL)
 127     return NULL;
 128   elf_tdata (abfd) = new_tdata;
 129
 130   /* Swap in the rest of the header, now that we have the byte order.  */
 131   i_ehdrp = elf_elfheader (abfd);
 132   elf_swap_ehdr_in (abfd, &x_ehdr, i_ehdrp);
 133
 134 #if DEBUG & 1
 135   elf_debug_file (i_ehdrp);
 136 #endif
 137
 138   ebd = get_elf_backend_data (abfd);
 139
 140   /* Check that the ELF e_machine field matches what this particular
 141      BFD format expects.  */
 142
 143   if (ebd->elf_machine_code != i_ehdrp->e_machine
 144       && (ebd->elf_machine_alt1 == 0
 145           || i_ehdrp->e_machine != ebd->elf_machine_alt1)
 146       && (ebd->elf_machine_alt2 == 0
 147           || i_ehdrp->e_machine != ebd->elf_machine_alt2))
 148     {
 149       const bfd_target * const *target_ptr;
 150
 151       if (ebd->elf_machine_code != EM_NONE)
 152         goto wrong;
 153
 154       /* This is the generic ELF target.  Let it match any ELF target
 155          for which we do not have a specific backend.  */
 156
 157       for (target_ptr = bfd_target_vector; *target_ptr != NULL; target_ptr++)
 158         {
 159           struct elf_backend_data *back;
 160
 161           if ((*target_ptr)->flavour != bfd_target_elf_flavour)
 162             continue;
 163           back = (struct elf_backend_data *) (*target_ptr)->backend_data;
 164           if (back->elf_machine_code == i_ehdrp->e_machine)
 165             {
 166               /* target_ptr is an ELF backend which matches this
 167                  object file, so reject the generic ELF target.  */
 168               goto wrong;
 169             }
 170         }
 171     }
 172
 173   /* If there is no program header, or the type is not a core file, then
 174      we are hosed.  */
 175   if (i_ehdrp->e_phoff == 0 || i_ehdrp->e_type != ET_CORE)
 176     goto wrong;
 177
 178   /* Does BFD's idea of the phdr size match the size
 179      recorded in the file? */
 180   if (i_ehdrp->e_phentsize != sizeof (Elf_External_Phdr))
 181     goto wrong;
 182
 183   /* Move to the start of the program headers.  */
 184   if (bfd_seek (abfd, i_ehdrp->e_phoff, SEEK_SET) != 0)
 185     goto wrong;
 186
 187   /* Allocate space for the program headers.  */
 188   i_phdrp = (Elf_Internal_Phdr *)
 189     bfd_alloc (abfd, sizeof (*i_phdrp) * i_ehdrp->e_phnum);
 190   if (!i_phdrp)
 191     goto fail;
 192
 193   elf_tdata (abfd)->phdr = i_phdrp;
 194
 195   /* Read and convert to internal form.  */
 196   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 197     {
 198       Elf_External_Phdr x_phdr;
 199       if (bfd_read ((PTR) &x_phdr, sizeof (x_phdr), 1, abfd)
 200           != sizeof (x_phdr))
 201         goto fail;
 202
 203       elf_swap_phdr_in (abfd, &x_phdr, i_phdrp + phindex);
 204     }
 205
 206   /* Process each program header.  */
 207   for (phindex = 0; phindex < i_ehdrp->e_phnum; ++phindex)
 208     {
 209       if (! bfd_section_from_phdr (abfd, i_phdrp + phindex, phindex))
 210         goto fail;
 211     }
 212
 213   /* Set the machine architecture.  */
 214   if (! bfd_default_set_arch_mach (abfd, ebd->arch, 0))
 215     {
 216       /* It's OK if this fails for the generic target.  */
 217       if (ebd->elf_machine_code != EM_NONE)
 218         goto fail;
 219     }
 220
 221   /* Save the entry point from the ELF header.  */
 222   bfd_get_start_address (abfd) = i_ehdrp->e_entry;
 223
 224   /* Let the backend double check the format and override global
 225      information.  */
 226   if (ebd->elf_backend_object_p)
 227     {
 228       if ((*ebd->elf_backend_object_p) (abfd) == false)
 229         goto wrong;
 230     }
 231
 232   return abfd->xvec;
 233
 234 wrong:
 235   bfd_set_error (bfd_error_wrong_format);
 236 fail:
 237   if (i_phdrp != NULL)
 238     bfd_release (abfd, i_phdrp);
 239   if (new_tdata != NULL)
 240     bfd_release (abfd, new_tdata);
 241   elf_tdata (abfd) = preserved_tdata;
 242   return NULL;
 243 }