gdb/core.c

   1 /* Work with core dump and executable files, for GDB.
   2    Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 GDB 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 1, or (at your option)
   9 any later version.
  10
  11 GDB 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 GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <stdio.h>
  21 #include <errno.h>
  22 #include <signal.h>
  23 #include "defs.h"
  24 #include "param.h"
  25 #include "frame.h"  /* required by inferior.h */
  26 #include "inferior.h"
  27 #include "symtab.h"
  28 #include "command.h"
  29 #include "bfd.h"
  30 #include "target.h"
  31 #include "gdbcore.h"
  32
  33 extern int xfer_memory ();
  34 extern void child_attach (), child_create_inferior ();
  35
  36 extern int sys_nerr;
  37 extern char *sys_errlist[];
  38 extern char *sys_siglist[];
  39
  40 extern char registers[];
  41
  42 /* Hook for `exec_file_command' command to call.  */
  43
  44 void (*exec_file_display_hook) () = NULL;
  45
  46 struct section_table *core_sections, *core_sections_end;
  47
  48 /* Binary file diddling handle for the core file.  */
  49
  50 bfd *core_bfd = NULL;
  51
  52 /* Forward decl */
  53 extern struct target_ops core_ops;
  54
  55 \f
  56 /* Discard all vestiges of any previous core file
  57    and mark data and stack spaces as empty.  */
  58
  59 /* ARGSUSED */
  60 void
  61 core_close (quitting)
  62      int quitting;
  63 {
  64   if (core_bfd) {
  65     free (bfd_get_filename (core_bfd));
  66     bfd_close (core_bfd);
  67     core_bfd = NULL;
  68 #ifdef CLEAR_SOLIB
  69     CLEAR_SOLIB ();
  70 #endif
  71   }
  72 }
  73
  74 /* This routine opens and sets up the core file bfd */
  75
  76 void
  77 core_open (filename, from_tty)
  78      char *filename;
  79      int from_tty;
  80 {
  81   char *p;
  82   int siggy;
  83   struct cleanup *old_chain;
  84   char *temp;
  85   bfd *temp_bfd;
  86   int ontop;
  87
  88   target_preopen (from_tty);
  89   if (!filename)
  90     {
  91       error (core_bfd?
  92        "No core file specified.  (Use `detach' to stop debugging a core file.)"
  93      : "No core file specified.");
  94     }
  95
  96   filename = tilde_expand (filename);
  97   if (filename[0] != '/') {
  98     temp = concat (current_directory, "/", filename);
  99     free (filename);
 100     filename = temp;
 101   }
 102
 103   old_chain = make_cleanup (free, filename);
 104   temp_bfd = bfd_openr (filename, NULL);
 105   if (temp_bfd == NULL)
 106     {
 107       perror_with_name (filename);
 108     }
 109
 110   if (!bfd_check_format (temp_bfd, bfd_core))
 111     {
 112       bfd_close (temp_bfd);
 113       error ("\"%s\" does not appear to be a core dump", filename);
 114     }
 115
 116   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 117
 118   discard_cleanups (old_chain);         /* Don't free filename any more */
 119   unpush_target (&core_ops);
 120   core_bfd = temp_bfd;
 121   old_chain = make_cleanup (core_close, core_bfd);
 122
 123   validate_files ();
 124
 125   /* Find the data section */
 126   if (build_section_table (core_bfd, &core_sections, &core_sections_end))
 127     error ("Can't find sections in `%s': %s", bfd_get_filename(core_bfd),
 128            bfd_errmsg (bfd_error));
 129
 130   ontop = !push_target (&core_ops);
 131   make_cleanup (unpush_target, &core_ops);
 132
 133   p = bfd_core_file_failing_command (core_bfd);
 134   if (p)
 135     printf ("Core file invoked as `%s'.\n", p);
 136
 137   siggy = bfd_core_file_failing_signal (core_bfd);
 138   if (siggy > 0)
 139     printf ("Program terminated with signal %d, %s.\n", siggy,
 140             siggy < NSIG ? sys_siglist[siggy] : "(undocumented)");
 141
 142   if (ontop) {
 143     /* Fetch all registers from core file */
 144     target_fetch_registers (-1);
 145     set_current_frame ( create_new_frame (read_register (FP_REGNUM),
 146                                           read_pc ()));
 147     select_frame (get_current_frame (), 0);
 148 #ifdef SOLIB_ADD
 149     SOLIB_ADD (NULL, from_tty);
 150 #endif
 151     print_sel_frame (0);        /* Print the top frame and source line */
 152   } else {
 153     printf (
 154 "Warning: you won't be able to access this core file until you terminate\n\
 155 your %s; do ``info files''\n", current_target->to_longname);
 156   }
 157
 158   discard_cleanups (old_chain);
 159 }
 160
 161 void
 162 core_detach (args, from_tty)
 163      char *args;
 164      int from_tty;
 165 {
 166   if (args)
 167     error ("Too many arguments");
 168   unpush_target (&core_ops);
 169   if (from_tty)
 170     printf ("No core file now.\n");
 171 }
 172
 173 /* Backward compatability with old way of specifying core files.  */
 174
 175 void
 176 core_file_command (filename, from_tty)
 177      char *filename;
 178      int from_tty;
 179 {
 180   dont_repeat ();                       /* Either way, seems bogus. */
 181   if (!filename)
 182     core_detach (filename, from_tty);
 183   else
 184     core_open (filename, from_tty);
 185 }
 186
 187 \f
 188 /* Call this to specify the hook for exec_file_command to call back.
 189    This is called from the x-window display code.  */
 190
 191 void
 192 specify_exec_file_hook (hook)
 193      void (*hook) ();
 194 {
 195   exec_file_display_hook = hook;
 196 }
 197
 198 /* The exec file must be closed before running an inferior.
 199    If it is needed again after the inferior dies, it must
 200    be reopened.  */
 201
 202 void
 203 close_exec_file ()
 204 {
 205 #ifdef FIXME
 206   if (exec_bfd)
 207     bfd_tempclose (exec_bfd);
 208 #endif
 209 }
 210
 211 void
 212 reopen_exec_file ()
 213 {
 214 #ifdef FIXME
 215   if (exec_bfd)
 216     bfd_reopen (exec_bfd);
 217 #endif
 218 }
 219 \f
 220 /* If we have both a core file and an exec file,
 221    print a warning if they don't go together.
 222    This should really check that the core file came
 223    from that exec file, but I don't know how to do it.  */
 224
 225 void
 226 validate_files ()
 227 {
 228   if (exec_bfd && core_bfd)
 229     {
 230       if (core_file_matches_executable_p (core_bfd, exec_bfd))
 231         printf ("Warning: core file does not match specified executable file.\n");
 232       else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
 233         printf ("Warning: exec file is newer than core file.\n");
 234     }
 235 }
 236
 237 /* Return the name of the executable file as a string.
 238    ERR nonzero means get error if there is none specified;
 239    otherwise return 0 in that case.  */
 240
 241 char *
 242 get_exec_file (err)
 243      int err;
 244 {
 245   if (exec_bfd) return bfd_get_filename(exec_bfd);
 246   if (!err)     return NULL;
 247
 248   error ("No executable file specified.\n\
 249 Use the \"file\" or \"exec-file\" command.");
 250   return NULL;
 251 }
 252
 253 static void
 254 core_files_info ()
 255 {
 256   struct section_table *p;
 257
 258   printf ("\tCore file `%s'.\n", bfd_get_filename(core_bfd));
 259
 260   for (p = core_sections; p < core_sections_end; p++)
 261     printf("\tcore file  from 0x%08x to 0x%08x is %s\n",
 262         p->addr, p->endaddr,
 263         bfd_section_name (core_bfd, p->sec_ptr));
 264 }
 265 \f
 266 void
 267 memory_error (status, memaddr)
 268      int status;
 269      CORE_ADDR memaddr;
 270 {
 271
 272   if (status == EIO)
 273     {
 274       /* Actually, address between memaddr and memaddr + len
 275          was out of bounds. */
 276       error ("Cannot access memory: address 0x%x out of bounds.", memaddr);
 277     }
 278   else
 279     {
 280       if (status >= sys_nerr || status < 0)
 281         error ("Error accessing memory address 0x%x: unknown error (%d).",
 282                memaddr, status);
 283       else
 284         error ("Error accessing memory address 0x%x: %s.",
 285                memaddr, sys_errlist[status]);
 286     }
 287 }
 288
 289 /* Same as target_read_memory, but report an error if can't read.  */
 290 void
 291 read_memory (memaddr, myaddr, len)
 292      CORE_ADDR memaddr;
 293      char *myaddr;
 294      int len;
 295 {
 296   int status;
 297   status = target_read_memory (memaddr, myaddr, len);
 298   if (status != 0)
 299     memory_error (status, memaddr);
 300 }
 301
 302 /* Same as target_write_memory, but report an error if can't write.  */
 303 void
 304 write_memory (memaddr, myaddr, len)
 305      CORE_ADDR memaddr;
 306      char *myaddr;
 307      int len;
 308 {
 309   int status;
 310
 311   status = target_write_memory (memaddr, myaddr, len);
 312   if (status != 0)
 313     memory_error (status, memaddr);
 314 }
 315
 316 /* Read an integer from debugged memory, given address and number of bytes.  */
 317
 318 long
 319 read_memory_integer (memaddr, len)
 320      CORE_ADDR memaddr;
 321      int len;
 322 {
 323   char cbuf;
 324   short sbuf;
 325   int ibuf;
 326   long lbuf;
 327
 328   if (len == sizeof (char))
 329     {
 330       read_memory (memaddr, &cbuf, len);
 331       return cbuf;
 332     }
 333   if (len == sizeof (short))
 334     {
 335       read_memory (memaddr, (char *)&sbuf, len);
 336       SWAP_TARGET_AND_HOST (&sbuf, sizeof (short));
 337       return sbuf;
 338     }
 339   if (len == sizeof (int))
 340     {
 341       read_memory (memaddr, (char *)&ibuf, len);
 342       SWAP_TARGET_AND_HOST (&ibuf, sizeof (int));
 343       return ibuf;
 344     }
 345   if (len == sizeof (lbuf))
 346     {
 347       read_memory (memaddr, (char *)&lbuf, len);
 348       SWAP_TARGET_AND_HOST (&lbuf, sizeof (lbuf));
 349       return lbuf;
 350     }
 351   error ("Cannot handle integers of %d bytes.", len);
 352   return -1;    /* for lint */
 353 }
 354 \f
 355 /* Read or write the core file.
 356
 357    Args are address within core file, address within gdb address-space,
 358    length, and a flag indicating whether to read or write.
 359
 360    Result is a length:
 361
 362         0:    We cannot handle this address and length.
 363         > 0:  We have handled N bytes starting at this address.
 364               (If N == length, we did it all.)  We might be able
 365               to handle more bytes beyond this length, but no
 366               promises.
 367         < 0:  We cannot handle this address, but if somebody
 368               else handles (-N) bytes, we can start from there.
 369
 370    The actual work is done by xfer_memory in exec.c, which we share
 371    in common with exec_xfer_memory().  */
 372
 373 static int
 374 core_xfer_memory (memaddr, myaddr, len, write)
 375      CORE_ADDR memaddr;
 376      char *myaddr;
 377      int len;
 378      int write;
 379 {
 380   int res;
 381   res = xfer_memory (memaddr, myaddr, len, write,
 382                       core_bfd, core_sections, core_sections_end);
 383 #ifdef SOLIB_XFER_MEMORY
 384   if (res == 0)
 385     res = SOLIB_XFER_MEMORY (memaddr, myaddr, len, write);
 386 #endif
 387   return res;
 388 }
 389 \f
 390 /* Get the registers out of a core file.  This is the machine-
 391    independent part.  Fetch_core_registers is the machine-dependent
 392    part, typically implemented in the xm-file for each architecture.  */
 393
 394 /* We just get all the registers, so we don't use regno.  */
 395 /* ARGSUSED */
 396 static int
 397 get_core_registers (regno)
 398      int regno;
 399 {
 400   sec_ptr reg_sec;
 401   unsigned size;
 402   char *the_regs;
 403
 404   reg_sec = bfd_get_section_by_name (core_bfd, ".reg");
 405   size = bfd_section_size (core_bfd, reg_sec);
 406   the_regs = alloca (size);
 407   if (bfd_get_section_contents (core_bfd, reg_sec, the_regs,
 408                                 (unsigned)0, size))
 409     {
 410       fetch_core_registers (the_regs, size, 0);
 411     }
 412   else
 413     {
 414       fprintf (stderr, "Couldn't fetch registers from core file: %s\n",
 415                bfd_errmsg (bfd_error));
 416     }
 417
 418   /* Now do it again for the float registers, if they exist.  */
 419   reg_sec = bfd_get_section_by_name (core_bfd, ".reg2");
 420   if (reg_sec) {
 421     size = bfd_section_size (core_bfd, reg_sec);
 422     the_regs = alloca (size);
 423     if (bfd_get_section_contents (core_bfd, reg_sec, the_regs,
 424                                   (unsigned)0, size))
 425       {
 426         fetch_core_registers (the_regs, size, 2);
 427       }
 428     else
 429       {
 430         fprintf (stderr, "Couldn't fetch register set 2 from core file: %s\n",
 431                  bfd_errmsg (bfd_error));
 432       }
 433   }
 434   registers_fetched();
 435   return 0;  /* FIXME, what result goes here?  */
 436 }
 437 \f
 438 struct target_ops core_ops = {
 439         "core", "Local core dump file",
 440         "Use a core file as a target.  Specify the filename of the core file.",
 441         core_open, core_close,
 442         child_attach, core_detach, 0, 0, /* resume, wait */
 443         get_core_registers,
 444         0, 0, 0, 0, /* store_regs, prepare_to_store, conv_to, conv_from */
 445         core_xfer_memory, core_files_info,
 446         0, 0, /* core_insert_breakpoint, core_remove_breakpoint, */
 447         0, 0, 0, 0, 0, /* terminal stuff */
 448         0, 0, 0, 0, 0, /* kill, load, add_syms, call fn, lookup sym */
 449         child_create_inferior, 0, /* mourn_inferior */
 450         core_stratum, 0, /* next */
 451         0, 1, 1, 1, 0,  /* all mem, mem, stack, regs, exec */
 452         OPS_MAGIC,              /* Always the last thing */
 453 };
 454
 455 void
 456 _initialize_core()
 457 {
 458
 459   add_com ("core-file", class_files, core_file_command,
 460            "Use FILE as core dump for examining memory and registers.\n\
 461 No arg means have no core file.  This command has been superseded by the\n\
 462 `target core' and `detach' commands.");
 463   add_target (&core_ops);
 464 }