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