gdb/core.c

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