gdb/corefile.c

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