gdb/corefile.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2003, 2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "gdb_string.h"
  23 #include <errno.h>
  24 #include <signal.h>
  25 #include <fcntl.h>
  26 #include "inferior.h"
  27 #include "symtab.h"
  28 #include "command.h"
  29 #include "gdbcmd.h"
  30 #include "bfd.h"
  31 #include "target.h"
  32 #include "gdbcore.h"
  33 #include "dis-asm.h"
  34 #include "gdb_stat.h"
  35 #include "completer.h"
  36 #include "exceptions.h"
  37
  38 /* Local function declarations.  */
  39
  40 extern void _initialize_core (void);
  41 static void call_extra_exec_file_hooks (char *filename);
  42
  43 /* You can have any number of hooks for `exec_file_command' command to
  44    call.  If there's only one hook, it is set in exec_file_display
  45    hook.  If there are two or more hooks, they are set in
  46    exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
  47    set to a function that calls all of them.  This extra complexity is
  48    needed to preserve compatibility with old code that assumed that
  49    only one hook could be set, and which called
  50    deprecated_exec_file_display_hook directly.  */
  51
  52 typedef void (*hook_type) (char *);
  53
  54 hook_type deprecated_exec_file_display_hook;    /* the original hook */
  55 static hook_type *exec_file_extra_hooks;        /* array of additional hooks */
  56 static int exec_file_hook_count = 0;    /* size of array */
  57
  58 /* Binary file diddling handle for the core file.  */
  59
  60 bfd *core_bfd = NULL;
  61 \f
  62
  63 /* Backward compatability with old way of specifying core files.  */
  64
  65 void
  66 core_file_command (char *filename, int from_tty)
  67 {
  68   struct target_ops *t;
  69
  70   dont_repeat ();               /* Either way, seems bogus. */
  71
  72   t = find_core_target ();
  73   if (t == NULL)
  74     error (_("GDB can't read core files on this machine."));
  75
  76   if (!filename)
  77     (t->to_detach) (t, filename, from_tty);
  78   else
  79     (t->to_open) (filename, from_tty);
  80 }
  81 \f
  82
  83 /* If there are two or more functions that wish to hook into
  84    exec_file_command, this function will call all of the hook
  85    functions.  */
  86
  87 static void
  88 call_extra_exec_file_hooks (char *filename)
  89 {
  90   int i;
  91
  92   for (i = 0; i < exec_file_hook_count; i++)
  93     (*exec_file_extra_hooks[i]) (filename);
  94 }
  95
  96 /* Call this to specify the hook for exec_file_command to call back.
  97    This is called from the x-window display code.  */
  98
  99 void
 100 specify_exec_file_hook (void (*hook) (char *))
 101 {
 102   hook_type *new_array;
 103
 104   if (deprecated_exec_file_display_hook != NULL)
 105     {
 106       /* There's already a hook installed.  Arrange to have both it
 107        * and the subsequent hooks called. */
 108       if (exec_file_hook_count == 0)
 109         {
 110           /* If this is the first extra hook, initialize the hook array.  */
 111           exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type));
 112           exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
 113           deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
 114           exec_file_hook_count = 1;
 115         }
 116
 117       /* Grow the hook array by one and add the new hook to the end.
 118          Yes, it's inefficient to grow it by one each time but since
 119          this is hardly ever called it's not a big deal.  */
 120       exec_file_hook_count++;
 121       new_array =
 122         (hook_type *) xrealloc (exec_file_extra_hooks,
 123                                 exec_file_hook_count * sizeof (hook_type));
 124       exec_file_extra_hooks = new_array;
 125       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
 126     }
 127   else
 128     deprecated_exec_file_display_hook = hook;
 129 }
 130
 131 /* The exec file must be closed before running an inferior.
 132    If it is needed again after the inferior dies, it must
 133    be reopened.  */
 134
 135 void
 136 close_exec_file (void)
 137 {
 138 #if 0                           /* FIXME */
 139   if (exec_bfd)
 140     bfd_tempclose (exec_bfd);
 141 #endif
 142 }
 143
 144 void
 145 reopen_exec_file (void)
 146 {
 147 #if 0                           /* FIXME */
 148   if (exec_bfd)
 149     bfd_reopen (exec_bfd);
 150 #else
 151   char *filename;
 152   int res;
 153   struct stat st;
 154   long mtime;
 155
 156   /* Don't do anything if there isn't an exec file. */
 157   if (exec_bfd == NULL)
 158     return;
 159
 160   /* If the timestamp of the exec file has changed, reopen it. */
 161   filename = xstrdup (bfd_get_filename (exec_bfd));
 162   make_cleanup (xfree, filename);
 163   res = stat (filename, &st);
 164
 165   if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
 166     exec_file_attach (filename, 0);
 167   else
 168     /* If we accessed the file since last opening it, close it now;
 169        this stops GDB from holding the executable open after it
 170        exits.  */
 171     bfd_cache_close_all ();
 172 #endif
 173 }
 174 \f
 175 /* If we have both a core file and an exec file,
 176    print a warning if they don't go together.  */
 177
 178 void
 179 validate_files (void)
 180 {
 181   if (exec_bfd && core_bfd)
 182     {
 183       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 184         warning (_("core file may not match specified executable file."));
 185       else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
 186         warning (_("exec file is newer than core file."));
 187     }
 188 }
 189
 190 /* Return the name of the executable file as a string.
 191    ERR nonzero means get error if there is none specified;
 192    otherwise return 0 in that case.  */
 193
 194 char *
 195 get_exec_file (int err)
 196 {
 197   if (exec_bfd)
 198     return bfd_get_filename (exec_bfd);
 199   if (!err)
 200     return NULL;
 201
 202   error (_("No executable file specified.\n\
 203 Use the \"file\" or \"exec-file\" command."));
 204   return NULL;
 205 }
 206 \f
 207
 208 /* Report a memory error by throwing a MEMORY_ERROR error.  */
 209
 210 void
 211 memory_error (int status, CORE_ADDR memaddr)
 212 {
 213   if (status == EIO)
 214     /* Actually, address between memaddr and memaddr + len was out of
 215        bounds.  */
 216     throw_error (MEMORY_ERROR,
 217                  _("Cannot access memory at address %s"),
 218                  paddress (memaddr));
 219   else
 220     throw_error (MEMORY_ERROR,
 221                  _("Error accessing memory address %s: %s."),
 222                  paddress (memaddr),
 223                  safe_strerror (status));
 224 }
 225
 226 /* Same as target_read_memory, but report an error if can't read.  */
 227 void
 228 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 229 {
 230   int status;
 231   status = target_read_memory (memaddr, myaddr, len);
 232   if (status != 0)
 233     memory_error (status, memaddr);
 234 }
 235
 236 /* Argument / return result struct for use with
 237    do_captured_read_memory_integer().  MEMADDR and LEN are filled in
 238    by gdb_read_memory_integer().  RESULT is the contents that were
 239    successfully read from MEMADDR of length LEN.  */
 240
 241 struct captured_read_memory_integer_arguments
 242 {
 243   CORE_ADDR memaddr;
 244   int len;
 245   LONGEST result;
 246 };
 247
 248 /* Helper function for gdb_read_memory_integer().  DATA must be a
 249    pointer to a captured_read_memory_integer_arguments struct.
 250    Return 1 if successful.  Note that the catch_errors() interface
 251    will return 0 if an error occurred while reading memory.  This
 252    choice of return code is so that we can distinguish between
 253    success and failure.  */
 254
 255 static int
 256 do_captured_read_memory_integer (void *data)
 257 {
 258   struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
 259   CORE_ADDR memaddr = args->memaddr;
 260   int len = args->len;
 261
 262   args->result = read_memory_integer (memaddr, len);
 263
 264   return 1;
 265 }
 266
 267 /* Read memory at MEMADDR of length LEN and put the contents in
 268    RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
 269    if successful.  */
 270
 271 int
 272 safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
 273 {
 274   int status;
 275   struct captured_read_memory_integer_arguments args;
 276   args.memaddr = memaddr;
 277   args.len = len;
 278
 279   status = catch_errors (do_captured_read_memory_integer, &args,
 280                         "", RETURN_MASK_ALL);
 281   if (status)
 282     *return_value = args.result;
 283
 284   return status;
 285 }
 286
 287 LONGEST
 288 read_memory_integer (CORE_ADDR memaddr, int len)
 289 {
 290   gdb_byte buf[sizeof (LONGEST)];
 291
 292   read_memory (memaddr, buf, len);
 293   return extract_signed_integer (buf, len);
 294 }
 295
 296 ULONGEST
 297 read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
 298 {
 299   gdb_byte buf[sizeof (ULONGEST)];
 300
 301   read_memory (memaddr, buf, len);
 302   return extract_unsigned_integer (buf, len);
 303 }
 304
 305 void
 306 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 307 {
 308   char *cp;
 309   int i;
 310   int cnt;
 311
 312   cp = buffer;
 313   while (1)
 314     {
 315       if (cp - buffer >= max_len)
 316         {
 317           buffer[max_len - 1] = '\0';
 318           break;
 319         }
 320       cnt = max_len - (cp - buffer);
 321       if (cnt > 8)
 322         cnt = 8;
 323       read_memory (memaddr + (int) (cp - buffer), cp, cnt);
 324       for (i = 0; i < cnt && *cp; i++, cp++)
 325         ;                       /* null body */
 326
 327       if (i < cnt && !*cp)
 328         break;
 329     }
 330 }
 331
 332 CORE_ADDR
 333 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 334 {
 335   gdb_byte *buf = alloca (TYPE_LENGTH (type));
 336   read_memory (addr, buf, TYPE_LENGTH (type));
 337   return extract_typed_address (buf, type);
 338 }
 339
 340 /* Same as target_write_memory, but report an error if can't write.  */
 341 void
 342 write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
 343 {
 344   int status;
 345   status = target_write_memory (memaddr, myaddr, len);
 346   if (status != 0)
 347     memory_error (status, memaddr);
 348 }
 349
 350 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
 351 void
 352 write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
 353 {
 354   gdb_byte *buf = alloca (len);
 355   store_unsigned_integer (buf, len, value);
 356   write_memory (addr, buf, len);
 357 }
 358
 359 /* Store VALUE at ADDR in the inferior as a LEN-byte signed integer.  */
 360 void
 361 write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
 362 {
 363   gdb_byte *buf = alloca (len);
 364   store_signed_integer (buf, len, value);
 365   write_memory (addr, buf, len);
 366 }
 367
 368 \f
 369
 370 #if 0
 371 /* Enable after 4.12.  It is not tested.  */
 372
 373 /* Search code.  Targets can just make this their search function, or
 374    if the protocol has a less general search function, they can call this
 375    in the cases it can't handle.  */
 376 void
 377 generic_search (int len, char *data, char *mask, CORE_ADDR startaddr,
 378                 int increment, CORE_ADDR lorange, CORE_ADDR hirange,
 379                 CORE_ADDR *addr_found, char *data_found)
 380 {
 381   int i;
 382   CORE_ADDR curaddr = startaddr;
 383
 384   while (curaddr >= lorange && curaddr < hirange)
 385     {
 386       read_memory (curaddr, data_found, len);
 387       for (i = 0; i < len; ++i)
 388         if ((data_found[i] & mask[i]) != data[i])
 389           goto try_again;
 390       /* It matches.  */
 391       *addr_found = curaddr;
 392       return;
 393
 394     try_again:
 395       curaddr += increment;
 396     }
 397   *addr_found = (CORE_ADDR) 0;
 398   return;
 399 }
 400 #endif /* 0 */
 401 \f
 402 /* The current default bfd target.  Points to storage allocated for
 403    gnutarget_string.  */
 404 char *gnutarget;
 405
 406 /* Same thing, except it is "auto" not NULL for the default case.  */
 407 static char *gnutarget_string;
 408 static void
 409 show_gnutarget_string (struct ui_file *file, int from_tty,
 410                        struct cmd_list_element *c, const char *value)
 411 {
 412   fprintf_filtered (file, _("The current BFD target is \"%s\".\n"), value);
 413 }
 414
 415 static void set_gnutarget_command (char *, int, struct cmd_list_element *);
 416
 417 static void
 418 set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
 419 {
 420   if (strcmp (gnutarget_string, "auto") == 0)
 421     gnutarget = NULL;
 422   else
 423     gnutarget = gnutarget_string;
 424 }
 425
 426 /* Set the gnutarget.  */
 427 void
 428 set_gnutarget (char *newtarget)
 429 {
 430   if (gnutarget_string != NULL)
 431     xfree (gnutarget_string);
 432   gnutarget_string = savestring (newtarget, strlen (newtarget));
 433   set_gnutarget_command (NULL, 0, NULL);
 434 }
 435
 436 void
 437 _initialize_core (void)
 438 {
 439   struct cmd_list_element *c;
 440   c = add_cmd ("core-file", class_files, core_file_command, _("\
 441 Use FILE as core dump for examining memory and registers.\n\
 442 No arg means have no core file.  This command has been superseded by the\n\
 443 `target core' and `detach' commands."), &cmdlist);
 444   set_cmd_completer (c, filename_completer);
 445
 446
 447   add_setshow_string_noescape_cmd ("gnutarget", class_files,
 448                                    &gnutarget_string, _("\
 449 Set the current BFD target."), _("\
 450 Show the current BFD target."), _("\
 451 Use `set gnutarget auto' to specify automatic detection."),
 452                                    set_gnutarget_command,
 453                                    show_gnutarget_string,
 454                                    &setlist, &showlist);
 455
 456   if (getenv ("GNUTARGET"))
 457     set_gnutarget (getenv ("GNUTARGET"));
 458   else
 459     set_gnutarget ("auto");
 460 }