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