bfd/hppabsd-core.c

   1 /* BFD back-end for HPPA BSD core files.
   2    Copyright (C) 1993-2017 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.
  20
  21    Written by the Center for Software Science at the University of Utah
  22    and by Cygnus Support.
  23
  24    The core file structure for the Utah 4.3BSD and OSF1 ports on the
  25    PA is a mix between traditional cores and hpux cores -- just
  26    different enough that supporting this format would tend to add
  27    gross hacks to trad-core.c or hpux-core.c.  So instead we keep any
  28    gross hacks isolated to this file.  */
  29
  30 /* This file can only be compiled on systems which use HPPA-BSD style
  31    core files.
  32
  33    I would not expect this to be of use to any other host/target, but
  34    you never know.  */
  35
  36 #include "sysdep.h"
  37 #include "bfd.h"
  38 #include "libbfd.h"
  39
  40 #if defined (HOST_HPPABSD)
  41
  42 #include "machine/vmparam.h"
  43
  44 #include <sys/param.h>
  45 #include <sys/dir.h>
  46 #include <signal.h>
  47 #include <machine/reg.h>
  48 #include <sys/user.h>           /* After a.out.h  */
  49 #include <sys/file.h>
  50
  51 #define hppabsd_core_core_file_matches_executable_p generic_core_file_matches_executable_p
  52 #define hppabsd_core_core_file_pid _bfd_nocore_core_file_pid
  53
  54 /* These are stored in the bfd's tdata.  */
  55
  56 struct hppabsd_core_struct
  57 {
  58   int sig;
  59   char cmd[MAXCOMLEN + 1];
  60   asection *data_section;
  61   asection *stack_section;
  62   asection *reg_section;
  63 };
  64
  65 #define core_hdr(bfd) ((bfd)->tdata.hppabsd_core_data)
  66 #define core_signal(bfd)   (core_hdr(bfd)->sig)
  67 #define core_command(bfd)  (core_hdr(bfd)->cmd)
  68 #define core_datasec(bfd)  (core_hdr(bfd)->data_section)
  69 #define core_stacksec(bfd) (core_hdr(bfd)->stack_section)
  70 #define core_regsec(bfd)   (core_hdr(bfd)->reg_section)
  71
  72 static asection *
  73 make_bfd_asection (bfd *abfd,
  74                    const char *name,
  75                    flagword flags,
  76                    bfd_size_type size,
  77                    file_ptr offset,
  78                    unsigned int alignment_power)
  79 {
  80   asection *asect;
  81
  82   asect = bfd_make_section_with_flags (abfd, name, flags);
  83   if (!asect)
  84     return NULL;
  85
  86   asect->size = size;
  87   asect->filepos = offset;
  88   asect->alignment_power = alignment_power;
  89
  90   return asect;
  91 }
  92
  93 static const bfd_target *
  94 hppabsd_core_core_file_p (bfd *abfd)
  95 {
  96   int val;
  97   struct user u;
  98   struct hppabsd_core_struct *coredata;
  99   int clicksz;
 100
 101   /* Try to read in the u-area.  We will need information from this
 102      to know how to grok the rest of the core structures.  */
 103   val = bfd_bread ((void *) &u, (bfd_size_type) sizeof u, abfd);
 104   if (val != sizeof u)
 105     {
 106       if (bfd_get_error () != bfd_error_system_call)
 107         bfd_set_error (bfd_error_wrong_format);
 108       return NULL;
 109     }
 110
 111   /* Get the page size out of the u structure.  This will be different
 112      for PA 1.0 machines and PA 1.1 machines.   Yuk!  */
 113   clicksz = u.u_pcb.pcb_pgsz;
 114
 115   /* clicksz must be a power of two >= 2k.  */
 116   if (clicksz < 0x800
 117       || clicksz != (clicksz & -clicksz))
 118     {
 119       bfd_set_error (bfd_error_wrong_format);
 120       return NULL;
 121     }
 122
 123   /* Sanity checks.  Make sure the size of the core file matches the
 124      the size computed from information within the core itself.  */
 125   {
 126     struct stat statbuf;
 127
 128     if (bfd_stat (abfd, &statbuf) < 0)
 129       return NULL;
 130
 131     if (NBPG * (UPAGES + u.u_dsize + u.u_ssize) > statbuf.st_size)
 132       {
 133         bfd_set_error (bfd_error_file_truncated);
 134         return NULL;
 135       }
 136     if (clicksz * (UPAGES + u.u_dsize + u.u_ssize) < statbuf.st_size)
 137       {
 138         /* The file is too big.  Maybe it's not a core file
 139            or we otherwise have bad values for u_dsize and u_ssize).  */
 140         bfd_set_error (bfd_error_wrong_format);
 141         return NULL;
 142       }
 143   }
 144
 145   /* OK, we believe you.  You're a core file (sure, sure).  */
 146
 147   coredata = (struct hppabsd_core_struct *)
 148     bfd_zalloc (abfd, (bfd_size_type) sizeof (struct hppabsd_core_struct));
 149   if (!coredata)
 150     return NULL;
 151
 152   /* Make the core data and available via the tdata part of the BFD.  */
 153   abfd->tdata.hppabsd_core_data = coredata;
 154
 155   /* Create the sections.  */
 156   core_stacksec (abfd) = make_bfd_asection (abfd, ".stack",
 157                                            SEC_ALLOC + SEC_HAS_CONTENTS,
 158                                            clicksz * u.u_ssize,
 159                                            NBPG * (USIZE + KSTAKSIZE)
 160                                              + clicksz * u.u_dsize, 2);
 161   if (core_stacksec (abfd) == NULL)
 162     goto fail;
 163   core_stacksec (abfd)->vma = USRSTACK;
 164
 165   core_datasec (abfd) = make_bfd_asection (abfd, ".data",
 166                                           SEC_ALLOC + SEC_LOAD
 167                                             + SEC_HAS_CONTENTS,
 168                                           clicksz * u.u_dsize,
 169                                           NBPG * (USIZE + KSTAKSIZE), 2);
 170   if (core_datasec (abfd) == NULL)
 171     goto fail;
 172   core_datasec (abfd)->vma = UDATASEG;
 173
 174   core_regsec (abfd) = make_bfd_asection (abfd, ".reg",
 175                                          SEC_HAS_CONTENTS,
 176                                          KSTAKSIZE * NBPG,
 177                                          NBPG * USIZE, 2);
 178   if (core_regsec (abfd) == NULL)
 179     goto fail;
 180   core_regsec (abfd)->vma = 0;
 181
 182   strncpy (core_command (abfd), u.u_comm, MAXCOMLEN + 1);
 183   core_signal (abfd) = u.u_code;
 184   return abfd->xvec;
 185
 186  fail:
 187   bfd_release (abfd, abfd->tdata.any);
 188   abfd->tdata.any = NULL;
 189   bfd_section_list_clear (abfd);
 190   return NULL;
 191 }
 192
 193 static char *
 194 hppabsd_core_core_file_failing_command (bfd *abfd)
 195 {
 196   return core_command (abfd);
 197 }
 198
 199 static int
 200 hppabsd_core_core_file_failing_signal (bfd *abfd)
 201 {
 202   return core_signal (abfd);
 203 }
 204 \f
 205 /* If somebody calls any byte-swapping routines, shoot them.  */
 206 static void
 207 swap_abort (void)
 208 {
 209   /* This way doesn't require any declaration for ANSI to fuck up.  */
 210   abort ();
 211 }
 212
 213 #define NO_GET ((bfd_vma (*) (const void *)) swap_abort)
 214 #define NO_PUT ((void (*) (bfd_vma, void *)) swap_abort)
 215 #define NO_GETS ((bfd_signed_vma (*) (const void *)) swap_abort)
 216 #define NO_GET64 ((bfd_uint64_t (*) (const void *)) swap_abort)
 217 #define NO_PUT64 ((void (*) (bfd_uint64_t, void *)) swap_abort)
 218 #define NO_GETS64 ((bfd_int64_t (*) (const void *)) swap_abort)
 219
 220 const bfd_target core_hppabsd_vec =
 221   {
 222     "hppabsd-core",
 223     bfd_target_unknown_flavour,
 224     BFD_ENDIAN_BIG,             /* target byte order */
 225     BFD_ENDIAN_BIG,             /* target headers byte order */
 226     (HAS_RELOC | EXEC_P |       /* object flags */
 227      HAS_LINENO | HAS_DEBUG |
 228      HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 229     (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 230     0,                                                     /* symbol prefix */
 231     ' ',                                                   /* ar_pad_char */
 232     16,                                                    /* ar_max_namelen */
 233     NO_GET64, NO_GETS64, NO_PUT64,      /* 64 bit data */
 234     NO_GET, NO_GETS, NO_PUT,            /* 32 bit data */
 235     NO_GET, NO_GETS, NO_PUT,            /* 16 bit data */
 236     NO_GET64, NO_GETS64, NO_PUT64,      /* 64 bit hdrs */
 237     NO_GET, NO_GETS, NO_PUT,            /* 32 bit hdrs */
 238     NO_GET, NO_GETS, NO_PUT,            /* 16 bit hdrs */
 239
 240     {                           /* bfd_check_format */
 241       _bfd_dummy_target,                /* unknown format */
 242       _bfd_dummy_target,                /* object file */
 243       _bfd_dummy_target,                /* archive */
 244       hppabsd_core_core_file_p          /* a core file */
 245     },
 246     {                           /* bfd_set_format */
 247       bfd_false, bfd_false,
 248       bfd_false, bfd_false
 249     },
 250     {                           /* bfd_write_contents */
 251       bfd_false, bfd_false,
 252       bfd_false, bfd_false
 253     },
 254
 255     BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 256     BFD_JUMP_TABLE_COPY (_bfd_generic),
 257     BFD_JUMP_TABLE_CORE (hppabsd_core),
 258     BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 259     BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
 260     BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 261     BFD_JUMP_TABLE_WRITE (_bfd_generic),
 262     BFD_JUMP_TABLE_LINK (_bfd_nolink),
 263     BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 264
 265     NULL,
 266
 267     NULL                        /* backend_data */
 268   };
 269 #endif