bfd/sco5-core.c

   1 /* BFD back end for SCO5 core files (U-area and raw sections)
   2    Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   3    Written by Jouke Numan <jnuman@hiscom.nl>
   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 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "libaout.h"           /* BFD a.out internal data structures */
  25
  26 #include <stdio.h>
  27 #include <sys/types.h>
  28 #include <sys/param.h>
  29 #include <sys/dir.h>
  30 #include <signal.h>
  31
  32 #include <sys/user.h>           /* After a.out.h  */
  33 #include <sys/paccess.h>
  34 #include <sys/region.h>
  35
  36 struct sco5_core_struct
  37 {
  38   struct user u;
  39 };
  40
  41 /* forward declarations */
  42
  43 static asection *
  44 make_bfd_asection PARAMS ((bfd *, const char *, flagword, bfd_size_type,
  45                            bfd_vma, file_ptr));
  46 static asymbol *sco5_core_make_empty_symbol PARAMS ((bfd *));
  47 static struct user *read_uarea PARAMS ((bfd *, int));
  48 const bfd_target *sco5_core_file_p PARAMS ((bfd *abfd));
  49 char *sco5_core_file_failing_command PARAMS ((bfd *abfd));
  50 int sco5_core_file_failing_signal PARAMS ((bfd *abfd));
  51 boolean sco5_core_file_matches_executable_p PARAMS ((bfd *core_bfd,
  52                                                      bfd *exec_bfd));
  53 static void swap_abort PARAMS ((void));
  54
  55 static asection *
  56 make_bfd_asection (abfd, name, flags, _raw_size, vma, filepos)
  57      bfd *abfd;
  58      const char *name;
  59      flagword flags;
  60      bfd_size_type _raw_size;
  61      bfd_vma vma;
  62      file_ptr filepos;
  63 {
  64   asection *asect;
  65
  66   asect = bfd_make_section_anyway (abfd, name);
  67   if (!asect)
  68     return NULL;
  69   asect->flags = flags;
  70   asect->_raw_size = _raw_size;
  71   asect->vma = vma;
  72   asect->filepos = filepos;
  73   asect->alignment_power = 2;
  74
  75   return asect;
  76 }
  77
  78 static asymbol *
  79 sco5_core_make_empty_symbol (abfd)
  80      bfd *abfd;
  81 {
  82   asymbol *new;
  83
  84   new = (asymbol *) bfd_zalloc (abfd, (bfd_size_type) sizeof (asymbol));
  85   if (new)
  86     new->the_bfd = abfd;
  87   return new;
  88 }
  89
  90 static struct user *
  91 read_uarea(abfd, filepos)
  92      bfd *abfd;
  93      int filepos;
  94
  95 {
  96   struct sco5_core_struct *rawptr;
  97   bfd_size_type amt = sizeof (struct sco5_core_struct);
  98
  99   rawptr = (struct sco5_core_struct *) bfd_zmalloc (amt);
 100   if (rawptr == NULL)
 101     return NULL;
 102
 103   abfd->tdata.sco5_core_data = rawptr;
 104
 105   if (bfd_seek (abfd, (file_ptr) filepos, SEEK_SET) != 0
 106       || bfd_bread ((void *) &rawptr->u, (bfd_size_type) sizeof rawptr->u,
 107                    abfd) != sizeof rawptr->u)
 108     {
 109       bfd_set_error (bfd_error_wrong_format);
 110       return NULL;
 111     }
 112
 113   /* Sanity check perhaps??? */
 114   if (rawptr->u.u_dsize > 0x1000000)    /* Remember, it's in pages...  */
 115     {
 116       bfd_set_error (bfd_error_wrong_format);
 117       return NULL;
 118     }
 119   if (rawptr->u.u_ssize > 0x1000000)
 120     {
 121       bfd_set_error (bfd_error_wrong_format);
 122       return NULL;
 123     }
 124   return &rawptr->u;
 125 }
 126
 127 /* ARGSUSED */
 128 const bfd_target *
 129 sco5_core_file_p (abfd)
 130      bfd *abfd;
 131 {
 132   int coffset_siz, val, nsecs, cheadoffs;
 133   int coresize;
 134   struct user *u;
 135   struct coreoffsets coffsets;
 136   struct coresecthead chead;
 137   char *secname;
 138   flagword flags;
 139
 140   /* Read coreoffsets region at end of core (see core(FP)) */
 141
 142   {
 143     FILE *stream = bfd_cache_lookup (abfd);
 144     struct stat statbuf;
 145     if (stream == NULL)
 146       return NULL;
 147     if (fstat (fileno (stream), &statbuf) < 0)
 148       {
 149         bfd_set_error (bfd_error_system_call);
 150         return NULL;
 151       }
 152     coresize = statbuf.st_size;
 153   }
 154   /* Last long in core is sizeof struct coreoffsets, read it */
 155   if ((bfd_seek (abfd, (file_ptr) (coresize - sizeof coffset_siz),
 156                  SEEK_SET) != 0)
 157       || bfd_bread ((void *) &coffset_siz, (bfd_size_type) sizeof coffset_siz,
 158                    abfd) != sizeof coffset_siz)
 159     {
 160       bfd_set_error (bfd_error_wrong_format);
 161       return NULL;
 162     }
 163
 164   /* Use it to seek start of coreoffsets region, read it and determine
 165      validity */
 166   if ((bfd_seek (abfd, (file_ptr) (coresize - coffset_siz), SEEK_SET) != 0)
 167       || (bfd_bread ((void *) &coffsets, (bfd_size_type) sizeof coffsets, abfd)
 168           != sizeof coffsets)
 169       || ((coffsets.u_info != 1) && (coffsets.u_info != C_VERSION)))
 170     {
 171       bfd_set_error (bfd_error_wrong_format);
 172       return NULL;
 173     }
 174
 175   if (coffsets.u_info == 1)
 176     {
 177       /* Old version, no section heads, read info from user struct */
 178
 179       u = read_uarea(abfd, coffsets.u_user);
 180       if (! u)
 181           return NULL;
 182
 183       if (!make_bfd_asection (abfd, ".reg", SEC_HAS_CONTENTS,
 184                               (bfd_size_type) coffsets.u_usize,
 185                               0 - (bfd_vma) u->u_ar0,
 186                               (file_ptr) coffsets.u_user))
 187         return NULL;
 188
 189       if (!make_bfd_asection (abfd, ".data",
 190                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
 191                               ((bfd_size_type) u->u_exdata.ux_dsize
 192                                + u->u_exdata.ux_bsize),
 193                               (bfd_vma) u->u_exdata.ux_datorg,
 194                               (file_ptr) coffsets.u_data))
 195         return NULL;
 196
 197       if (!make_bfd_asection (abfd, ".stack",
 198                               SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS,
 199                               (bfd_size_type) u->u_ssize * NBPC,
 200                               (bfd_vma) u->u_sub,
 201                               (file_ptr) coffsets.u_stack))
 202         return NULL;
 203
 204       return abfd->xvec;                /* Done for version 1 */
 205     }
 206
 207   /* Immediately before coreoffsets region is a long with offset in core
 208      to first coresecthead (CORES_OFFSETS), the long before this is the
 209      number of section heads in the list. Read both longs and read the
 210      coresecthead and check its validity */
 211
 212   if ((bfd_seek (abfd,
 213                  (file_ptr) (coresize - coffset_siz - 2 * sizeof coffset_siz),
 214                  SEEK_SET) != 0)
 215       || (bfd_bread ((void *) &nsecs, (bfd_size_type) sizeof nsecs, abfd)
 216           != sizeof nsecs)
 217       || (bfd_bread ((void *) &cheadoffs, (bfd_size_type) sizeof cheadoffs,
 218                     abfd) != sizeof cheadoffs)
 219       || (bfd_seek (abfd, (file_ptr) cheadoffs, SEEK_SET) != 0)
 220       || (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
 221           != sizeof chead)
 222       || (chead.cs_stype != CORES_OFFSETS)
 223       || (chead.cs_x.csx_magic != COREMAGIC_NUMBER))
 224     {
 225       bfd_set_error (bfd_error_wrong_format);
 226       return NULL;
 227     }
 228
 229   /* OK, we believe you.  You're a core file (sure, sure).  */
 230
 231   /* Now loop over all regions and map them */
 232   nsecs--;                              /* We've seen CORES_OFFSETS already */
 233   for (; nsecs; nsecs--)
 234     {
 235       if ((bfd_seek (abfd, (file_ptr) chead.cs_hseek, SEEK_SET) != 0)
 236           || (bfd_bread ((void *) &chead, (bfd_size_type) sizeof chead, abfd)
 237               != sizeof chead))
 238         {
 239           bfd_set_error (bfd_error_wrong_format);
 240           return NULL;
 241         }
 242
 243       switch (chead.cs_stype)
 244         {
 245         case CORES_MAGIC:                       /* Core header, check magic */
 246           if (chead.cs_x.csx_magic != COREMAGIC_NUMBER)
 247             {
 248               bfd_set_error (bfd_error_wrong_format);
 249               return NULL;
 250             }
 251           secname = NULL;
 252           nsecs++;                              /* MAGIC not in section cnt!*/
 253           break;
 254         case CORES_UAREA:                       /* U-area, read in tdata */
 255           u = read_uarea(abfd, chead.cs_sseek);
 256           if (! u)
 257             return NULL;
 258
 259           /* This is tricky.  As the "register section", we give them
 260              the entire upage and stack.  u.u_ar0 points to where
 261              "register 0" is stored.  There are two tricks with this,
 262              though.  One is that the rest of the registers might be
 263              at positive or negative (or both) displacements from
 264              *u_ar0.  The other is that u_ar0 is sometimes an absolute
 265              address in kernel memory, and on other systems it is an
 266              offset from the beginning of the `struct user'.
 267
 268              As a practical matter, we don't know where the registers
 269              actually are, so we have to pass the whole area to GDB.
 270              We encode the value of u_ar0 by setting the .regs section
 271              up so that its virtual memory address 0 is at the place
 272              pointed to by u_ar0 (by setting the vma of the start of
 273              the section to -u_ar0).  GDB uses this info to locate the
 274              regs, using minor trickery to get around the
 275              offset-or-absolute-addr problem.  */
 276
 277           chead.cs_vaddr = 0 - (bfd_vma) u->u_ar0;
 278
 279           secname = ".reg";
 280           flags = SEC_HAS_CONTENTS;
 281
 282           break;
 283         case CORES_PREGION:                     /* A program region, map it */
 284           switch (chead.cs_x.csx_preg.csxp_rtyp)
 285             {
 286             case PT_DATA:
 287               secname = ".data";        /* Data region.          */
 288               break;
 289             case PT_STACK:
 290               secname = ".stack";       /* Stack region.         */
 291               break;
 292             case PT_SHMEM:
 293               secname = ".shmem";       /* Shared memory         */
 294               break;
 295             case PT_LIBDAT:
 296               secname = ".libdat";      /* Shared library data   */
 297               break;
 298             case PT_V86:
 299               secname = ".virt86";      /* Virtual 8086 mode     */
 300               break;
 301             case PT_SHFIL:
 302               secname = ".mmfile";      /* Memory mapped file    */
 303               break;
 304             case PT_XDATA0:
 305               secname = ".Xdat0";       /* XENIX data region, virtual 0 */
 306               break;
 307             default:
 308               secname = "";
 309             }
 310           flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 311           break;
 312         case CORES_PROC:                        /* struct proc */
 313         case CORES_ITIMER:                      /* interval timers */
 314         case CORES_SCOUTSNAME:                  /* struct scoutsname */
 315           secname = NULL;       /* Ignore these */
 316           break;
 317         default:
 318           (*_bfd_error_handler) ("Unhandled SCO core file section type %d\n",
 319                                  chead.cs_stype);
 320           continue;
 321         }
 322
 323       if (secname
 324           && !make_bfd_asection (abfd, secname, flags,
 325                                  (bfd_size_type) chead.cs_vsize,
 326                                  (bfd_vma) chead.cs_vaddr,
 327                                  (file_ptr) chead.cs_sseek))
 328         return NULL;
 329
 330     }
 331
 332   return abfd->xvec;
 333
 334 }
 335
 336 char *
 337 sco5_core_file_failing_command (abfd)
 338      bfd *abfd;
 339 {
 340   char *com = abfd->tdata.sco5_core_data->u.u_comm;
 341   if (*com)
 342     return com;
 343   else
 344     return NULL;
 345 }
 346
 347 /* ARGSUSED */
 348 int
 349 sco5_core_file_failing_signal (ignore_abfd)
 350      bfd *ignore_abfd;
 351 {
 352   return ((ignore_abfd->tdata.sco5_core_data->u.u_sysabort != 0)
 353           ? ignore_abfd->tdata.sco5_core_data->u.u_sysabort
 354           : -1);
 355 }
 356
 357 /* ARGSUSED */
 358 boolean
 359 sco5_core_file_matches_executable_p  (core_bfd, exec_bfd)
 360      bfd *core_bfd ATTRIBUTE_UNUSED;
 361      bfd *exec_bfd ATTRIBUTE_UNUSED;
 362 {
 363   return true;          /* FIXME, We have no way of telling at this point */
 364 }
 365
 366 #define sco5_core_get_symtab_upper_bound _bfd_nosymbols_get_symtab_upper_bound
 367 #define sco5_core_get_symtab _bfd_nosymbols_get_symtab
 368 #define sco5_core_print_symbol _bfd_nosymbols_print_symbol
 369 #define sco5_core_get_symbol_info _bfd_nosymbols_get_symbol_info
 370 #define sco5_core_bfd_is_local_label_name _bfd_nosymbols_bfd_is_local_label_name
 371 #define sco5_core_get_lineno _bfd_nosymbols_get_lineno
 372 #define sco5_core_find_nearest_line _bfd_nosymbols_find_nearest_line
 373 #define sco5_core_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
 374 #define sco5_core_read_minisymbols _bfd_nosymbols_read_minisymbols
 375 #define sco5_core_minisymbol_to_symbol _bfd_nosymbols_minisymbol_to_symbol
 376
 377 /* If somebody calls any byte-swapping routines, shoot them.  */
 378 static void
 379 swap_abort ()
 380 {
 381   abort (); /* This way doesn't require any declaration for ANSI to fuck up */
 382 }
 383 #define NO_GET  ((bfd_vma (*) PARAMS ((   const bfd_byte *))) swap_abort )
 384 #define NO_PUT  ((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
 385 #define NO_SIGNED_GET \
 386   ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )
 387
 388 const bfd_target sco5_core_vec =
 389   {
 390     "sco5-core",
 391     bfd_target_unknown_flavour,
 392     BFD_ENDIAN_LITTLE,         /* target byte order */
 393     BFD_ENDIAN_LITTLE,         /* target headers byte order */
 394     (HAS_RELOC | EXEC_P |       /* object flags */
 395      HAS_LINENO | HAS_DEBUG |
 396      HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 397     (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 398     0,                                                     /* symbol prefix */
 399     ' ',                                                   /* ar_pad_char */
 400     16,                                                    /* ar_max_namelen */
 401     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit data */
 402     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit data */
 403     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit data */
 404     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit hdrs */
 405     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit hdrs */
 406     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit hdrs */
 407
 408     {                           /* bfd_check_format */
 409      _bfd_dummy_target,         /* unknown format */
 410      _bfd_dummy_target,         /* object file */
 411      _bfd_dummy_target,         /* archive */
 412      sco5_core_file_p           /* a core file */
 413     },
 414     {                           /* bfd_set_format */
 415      bfd_false, bfd_false,
 416      bfd_false, bfd_false
 417     },
 418     {                           /* bfd_write_contents */
 419      bfd_false, bfd_false,
 420      bfd_false, bfd_false
 421     },
 422
 423        BFD_JUMP_TABLE_GENERIC (_bfd_generic),
 424        BFD_JUMP_TABLE_COPY (_bfd_generic),
 425        BFD_JUMP_TABLE_CORE (sco5),
 426        BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 427        BFD_JUMP_TABLE_SYMBOLS (sco5_core),
 428        BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
 429        BFD_JUMP_TABLE_WRITE (_bfd_generic),
 430        BFD_JUMP_TABLE_LINK (_bfd_nolink),
 431        BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 432
 433     NULL,
 434
 435     (PTR) 0                     /* backend_data */
 436 };