bfd/trad-core.c

   1 /* BFD back end for traditional Unix core files (U-area and raw sections)
   2    Copyright 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Written by John Gilmore of Cygnus Support.
   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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* To use this file on a particular host, configure the host with these
  22    parameters in the config/h-HOST file:
  23
  24         HDEFINES=-DTRAD_CORE
  25         HDEPFILES=trad-core.o
  26
  27  */
  28
  29 #include "bfd.h"
  30 #include "sysdep.h"
  31 #include "libbfd.h"
  32 #include "libaout.h"           /* BFD a.out internal data structures */
  33
  34 #include <stdio.h>
  35 #include <sys/types.h>
  36 #include <sys/param.h>
  37 #include <sys/dir.h>
  38 #include <signal.h>
  39
  40 #include <sys/user.h>           /* After a.out.h  */
  41 #if 0
  42 /* file.h is included by std-host.h.  So we better not try to include it
  43    twice; on some systems (dpx2) it is not protected against multiple
  44    inclusion.  I have checked that all the hosts which use this file
  45    include sys/file.h in the hosts file.  */
  46 #include <sys/file.h>
  47 #endif
  48
  49 #include <errno.h>
  50
  51   struct trad_core_struct
  52     {
  53       asection *data_section;
  54       asection *stack_section;
  55       asection *reg_section;
  56       struct user u;
  57     } *rawptr;
  58
  59 #define core_upage(bfd) (&((bfd)->tdata.trad_core_data->u))
  60 #define core_datasec(bfd) ((bfd)->tdata.trad_core_data->data_section)
  61 #define core_stacksec(bfd) ((bfd)->tdata.trad_core_data->stack_section)
  62 #define core_regsec(bfd) ((bfd)->tdata.trad_core_data->reg_section)
  63
  64 /* forward declarations */
  65
  66 bfd_target *    trad_unix_core_file_p PARAMS ((bfd *abfd));
  67 char *          trad_unix_core_file_failing_command PARAMS ((bfd *abfd));
  68 int             trad_unix_core_file_failing_signal PARAMS ((bfd *abfd));
  69 boolean         trad_unix_core_file_matches_executable_p
  70                          PARAMS ((bfd *core_bfd, bfd *exec_bfd));
  71
  72 /* Handle 4.2-style (and perhaps also sysV-style) core dump file.  */
  73
  74 /* ARGSUSED */
  75 bfd_target *
  76 trad_unix_core_file_p (abfd)
  77      bfd *abfd;
  78
  79 {
  80   int val;
  81   struct user u;
  82
  83 #ifdef TRAD_CORE_USER_OFFSET
  84   /* If defined, this macro is the file position of the user struct.  */
  85   if (bfd_seek (abfd, TRAD_CORE_USER_OFFSET, SEEK_SET) != 0)
  86     return 0;
  87 #endif
  88
  89   val = bfd_read ((void *)&u, 1, sizeof u, abfd);
  90   if (val != sizeof u)
  91     {
  92       /* Too small to be a core file */
  93       bfd_set_error (bfd_error_wrong_format);
  94       return 0;
  95     }
  96
  97   /* Sanity check perhaps??? */
  98   if (u.u_dsize > 0x1000000)    /* Remember, it's in pages... */
  99     {
 100       bfd_set_error (bfd_error_wrong_format);
 101       return 0;
 102     }
 103   if (u.u_ssize > 0x1000000)
 104     {
 105       bfd_set_error (bfd_error_wrong_format);
 106       return 0;
 107     }
 108
 109   /* Check that the size claimed is no greater than the file size.  */
 110   {
 111     FILE *stream = bfd_cache_lookup (abfd);
 112     struct stat statbuf;
 113     if (stream == NULL)
 114       return 0;
 115     if (fstat (fileno (stream), &statbuf) < 0)
 116       {
 117         bfd_set_error (bfd_error_system_call);
 118         return 0;
 119       }
 120     if (NBPG * (UPAGES + u.u_dsize
 121 #ifdef TRAD_CORE_DSIZE_INCLUDES_TSIZE
 122                 - u.u_tsize
 123 #endif
 124                 + u.u_ssize) > statbuf.st_size)
 125       {
 126         bfd_set_error (bfd_error_file_truncated);
 127         return 0;
 128       }
 129 #ifndef TRAD_CORE_ALLOW_ANY_EXTRA_SIZE
 130     if (NBPG * (UPAGES + u.u_dsize + u.u_ssize)
 131 #ifdef TRAD_CORE_EXTRA_SIZE_ALLOWED
 132         /* Some systems write the file too big.  */
 133         + TRAD_CORE_EXTRA_SIZE_ALLOWED
 134 #endif
 135         < statbuf.st_size)
 136       {
 137         /* The file is too big.  Maybe it's not a core file
 138            or we otherwise have bad values for u_dsize and u_ssize).  */
 139         bfd_set_error (bfd_error_wrong_format);
 140         return 0;
 141       }
 142 #endif
 143   }
 144
 145   /* OK, we believe you.  You're a core file (sure, sure).  */
 146
 147   /* Allocate both the upage and the struct core_data at once, so
 148      a single free() will free them both.  */
 149   rawptr = (struct trad_core_struct *)
 150                 bfd_zmalloc (sizeof (struct trad_core_struct));
 151   if (rawptr == NULL) {
 152     bfd_set_error (bfd_error_no_memory);
 153     return 0;
 154   }
 155
 156   abfd->tdata.trad_core_data = rawptr;
 157
 158   rawptr->u = u; /*Copy the uarea into the tdata part of the bfd */
 159
 160   /* Create the sections.  This is raunchy, but bfd_close wants to free
 161      them separately.  */
 162
 163   core_stacksec(abfd) = (asection *) bfd_zmalloc (sizeof (asection));
 164   if (core_stacksec (abfd) == NULL) {
 165   loser:
 166     bfd_set_error (bfd_error_no_memory);
 167     free ((void *)rawptr);
 168     return 0;
 169   }
 170   core_datasec (abfd) = (asection *) bfd_zmalloc (sizeof (asection));
 171   if (core_datasec (abfd) == NULL) {
 172   loser1:
 173     free ((void *)core_stacksec (abfd));
 174     goto loser;
 175   }
 176   core_regsec (abfd) = (asection *) bfd_zmalloc (sizeof (asection));
 177   if (core_regsec (abfd) == NULL) {
 178     free ((void *)core_datasec (abfd));
 179     goto loser1;
 180   }
 181
 182   core_stacksec (abfd)->name = ".stack";
 183   core_datasec (abfd)->name = ".data";
 184   core_regsec (abfd)->name = ".reg";
 185
 186   core_stacksec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 187   core_datasec (abfd)->flags = SEC_ALLOC + SEC_LOAD + SEC_HAS_CONTENTS;
 188   core_regsec (abfd)->flags = SEC_ALLOC + SEC_HAS_CONTENTS;
 189
 190   core_datasec (abfd)->_raw_size =  NBPG * u.u_dsize
 191 #ifdef TRAD_CORE_DSIZE_INCLUDES_TSIZE
 192     - NBPG * u.u_tsize
 193 #endif
 194       ;
 195   core_stacksec (abfd)->_raw_size = NBPG * u.u_ssize;
 196   core_regsec (abfd)->_raw_size = NBPG * UPAGES; /* Larger than sizeof struct u */
 197
 198   /* What a hack... we'd like to steal it from the exec file,
 199      since the upage does not seem to provide it.  FIXME.  */
 200 #ifdef HOST_DATA_START_ADDR
 201   core_datasec (abfd)->vma = HOST_DATA_START_ADDR;
 202 #else
 203   core_datasec (abfd)->vma = HOST_TEXT_START_ADDR + (NBPG * u.u_tsize);
 204 #endif
 205
 206 #ifdef HOST_STACK_START_ADDR
 207   core_stacksec (abfd)->vma = HOST_STACK_START_ADDR;
 208 #else
 209   core_stacksec (abfd)->vma = HOST_STACK_END_ADDR - (NBPG * u.u_ssize);
 210 #endif
 211
 212   /* This is tricky.  As the "register section", we give them the entire
 213      upage and stack.  u.u_ar0 points to where "register 0" is stored.
 214      There are two tricks with this, though.  One is that the rest of the
 215      registers might be at positive or negative (or both) displacements
 216      from *u_ar0.  The other is that u_ar0 is sometimes an absolute address
 217      in kernel memory, and on other systems it is an offset from the beginning
 218      of the `struct user'.
 219
 220      As a practical matter, we don't know where the registers actually are,
 221      so we have to pass the whole area to GDB.  We encode the value of u_ar0
 222      by setting the .regs section up so that its virtual memory address
 223      0 is at the place pointed to by u_ar0 (by setting the vma of the start
 224      of the section to -u_ar0).  GDB uses this info to locate the regs,
 225      using minor trickery to get around the offset-or-absolute-addr problem. */
 226   core_regsec (abfd)->vma = 0 - (int) u.u_ar0;
 227
 228   core_datasec (abfd)->filepos = NBPG * UPAGES;
 229   core_stacksec (abfd)->filepos = (NBPG * UPAGES) + NBPG * u.u_dsize
 230 #ifdef TRAD_CORE_DSIZE_INCLUDES_TSIZE
 231     - NBPG * u.u_tsize
 232 #endif
 233       ;
 234   core_regsec (abfd)->filepos = 0; /* Register segment is the upage */
 235
 236   /* Align to word at least */
 237   core_stacksec (abfd)->alignment_power = 2;
 238   core_datasec (abfd)->alignment_power = 2;
 239   core_regsec (abfd)->alignment_power = 2;
 240
 241   abfd->sections = core_stacksec (abfd);
 242   core_stacksec (abfd)->next = core_datasec (abfd);
 243   core_datasec (abfd)->next = core_regsec (abfd);
 244   abfd->section_count = 3;
 245
 246   return abfd->xvec;
 247 }
 248
 249 char *
 250 trad_unix_core_file_failing_command (abfd)
 251      bfd *abfd;
 252 {
 253 #ifndef NO_CORE_COMMAND
 254   char *com = abfd->tdata.trad_core_data->u.u_comm;
 255   if (*com)
 256     return com;
 257   else
 258 #endif
 259     return 0;
 260 }
 261
 262 /* ARGSUSED */
 263 int
 264 trad_unix_core_file_failing_signal (ignore_abfd)
 265      bfd *ignore_abfd;
 266 {
 267 #ifdef TRAD_UNIX_CORE_FILE_FAILING_SIGNAL
 268   return TRAD_UNIX_CORE_FILE_FAILING_SIGNAL(ignore_abfd);
 269 #else
 270   return -1;            /* FIXME, where is it? */
 271 #endif
 272 }
 273
 274 /* ARGSUSED */
 275 boolean
 276 trad_unix_core_file_matches_executable_p  (core_bfd, exec_bfd)
 277      bfd *core_bfd, *exec_bfd;
 278 {
 279   return true;          /* FIXME, We have no way of telling at this point */
 280 }
 281 \f
 282 /* No archive file support via this BFD */
 283 #define trad_unix_openr_next_archived_file      bfd_generic_openr_next_archived_file
 284 #define trad_unix_generic_stat_arch_elt         bfd_generic_stat_arch_elt
 285 #define trad_unix_slurp_armap                   bfd_false
 286 #define trad_unix_slurp_extended_name_table     bfd_true
 287 #define trad_unix_write_armap                   (boolean (*) PARAMS     \
 288     ((bfd *arch, unsigned int elength, struct orl *map, \
 289       unsigned int orl_count, int stridx))) bfd_false
 290 #define trad_unix_truncate_arname               bfd_dont_truncate_arname
 291 #define aout_32_openr_next_archived_file        bfd_generic_openr_next_archived_file
 292
 293 #define trad_unix_close_and_cleanup             bfd_generic_close_and_cleanup
 294 #define trad_unix_set_section_contents          (boolean (*) PARAMS     \
 295         ((bfd *abfd, asection *section, PTR data, file_ptr offset,      \
 296         bfd_size_type count))) bfd_generic_set_section_contents
 297 #define trad_unix_get_section_contents          bfd_generic_get_section_contents
 298 #define trad_unix_new_section_hook              (boolean (*) PARAMS     \
 299         ((bfd *, sec_ptr))) bfd_true
 300 #define trad_unix_get_symtab_upper_bound        bfd_0l
 301 #define trad_unix_get_symtab                    (long (*) PARAMS \
 302         ((bfd *, struct symbol_cache_entry **))) bfd_0l
 303 #define trad_unix_get_reloc_upper_bound         (long (*) PARAMS \
 304         ((bfd *, sec_ptr))) bfd_0l
 305 #define trad_unix_canonicalize_reloc            (long (*) PARAMS \
 306         ((bfd *, sec_ptr, arelent **, struct symbol_cache_entry**))) bfd_0l
 307 #define trad_unix_make_empty_symbol             (struct symbol_cache_entry * \
 308         (*) PARAMS ((bfd *))) bfd_false
 309 #define trad_unix_print_symbol                  (void (*) PARAMS        \
 310         ((bfd *, PTR, struct symbol_cache_entry  *,                     \
 311         bfd_print_symbol_type))) bfd_false
 312 #define trad_unix_get_symbol_info               (void (*) PARAMS        \
 313         ((bfd *, struct symbol_cache_entry  *,                  \
 314         symbol_info *))) bfd_false
 315 #define trad_unix_get_lineno                    (alent * (*) PARAMS     \
 316         ((bfd *, struct symbol_cache_entry *))) bfd_nullvoidptr
 317 #define trad_unix_set_arch_mach                 (boolean (*) PARAMS     \
 318         ((bfd *, enum bfd_architecture, unsigned long))) bfd_false
 319 #define trad_unix_find_nearest_line             (boolean (*) PARAMS     \
 320         ((bfd *abfd, struct sec  *section,                              \
 321          struct symbol_cache_entry  **symbols,bfd_vma offset,           \
 322          CONST char **file, CONST char **func, unsigned int *line))) bfd_false
 323 #define trad_unix_sizeof_headers                (int (*) PARAMS \
 324         ((bfd *, boolean))) bfd_0
 325
 326 #define trad_unix_bfd_debug_info_start          bfd_void
 327 #define trad_unix_bfd_debug_info_end            bfd_void
 328 #define trad_unix_bfd_debug_info_accumulate     (void (*) PARAMS        \
 329         ((bfd *, struct sec *))) bfd_void
 330 #define trad_unix_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
 331 #define trad_unix_bfd_relax_section             bfd_generic_relax_section
 332 #define trad_unix_bfd_reloc_type_lookup \
 333   ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
 334 #define trad_unix_bfd_make_debug_symbol \
 335   ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
 336 #define trad_unix_bfd_link_hash_table_create \
 337   ((struct bfd_link_hash_table *(*) PARAMS ((bfd *))) bfd_nullvoidptr)
 338 #define trad_unix_bfd_link_add_symbols \
 339   ((boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) bfd_false)
 340 #define trad_unix_bfd_final_link \
 341   ((boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) bfd_false)
 342 #define trad_unix_bfd_copy_private_section_data \
 343   ((boolean (*) PARAMS ((bfd *, asection *, bfd *, asection *))) bfd_false)
 344 #define trad_unix_bfd_copy_private_bfd_data \
 345   ((boolean (*) PARAMS ((bfd *, bfd *))) bfd_false)
 346 #define trad_unix_bfd_is_local_label \
 347   ((boolean (*) PARAMS ((bfd *, asymbol *))) bfd_false)
 348 #define trad_unix_bfd_free_cached_info bfd_true
 349
 350 /* If somebody calls any byte-swapping routines, shoot them.  */
 351 void
 352 swap_abort()
 353 {
 354   abort(); /* This way doesn't require any declaration for ANSI to fuck up */
 355 }
 356 #define NO_GET  ((bfd_vma (*) PARAMS ((   const bfd_byte *))) swap_abort )
 357 #define NO_PUT  ((void    (*) PARAMS ((bfd_vma, bfd_byte *))) swap_abort )
 358 #define NO_SIGNED_GET \
 359   ((bfd_signed_vma (*) PARAMS ((const bfd_byte *))) swap_abort )
 360
 361 bfd_target trad_core_vec =
 362   {
 363     "trad-core",
 364     bfd_target_unknown_flavour,
 365     true,                       /* target byte order */
 366     true,                       /* target headers byte order */
 367     (HAS_RELOC | EXEC_P |       /* object flags */
 368      HAS_LINENO | HAS_DEBUG |
 369      HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 370     (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
 371     0,                                                     /* symbol prefix */
 372     ' ',                                                   /* ar_pad_char */
 373     16,                                                    /* ar_max_namelen */
 374     3,                                                     /* minimum alignment power */
 375     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit data */
 376     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit data */
 377     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit data */
 378     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 64 bit hdrs */
 379     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 32 bit hdrs */
 380     NO_GET, NO_SIGNED_GET, NO_PUT,      /* 16 bit hdrs */
 381
 382     {                           /* bfd_check_format */
 383      _bfd_dummy_target,         /* unknown format */
 384      _bfd_dummy_target,         /* object file */
 385      _bfd_dummy_target,         /* archive */
 386      trad_unix_core_file_p      /* a core file */
 387     },
 388     {                           /* bfd_set_format */
 389      bfd_false, bfd_false,
 390      bfd_false, bfd_false
 391     },
 392     {                           /* bfd_write_contents */
 393      bfd_false, bfd_false,
 394      bfd_false, bfd_false
 395     },
 396
 397     JUMP_TABLE(trad_unix),
 398     (PTR) 0                     /* backend_data */
 399 };