gdb/corefile.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2
   3    Copyright (C) 1986-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include <errno.h>
  22 #include <signal.h>
  23 #include <fcntl.h>
  24 #include "inferior.h"
  25 #include "symtab.h"
  26 #include "command.h"
  27 #include "gdbcmd.h"
  28 #include "bfd.h"
  29 #include "target.h"
  30 #include "gdbcore.h"
  31 #include "dis-asm.h"
  32 #include <sys/stat.h>
  33 #include "completer.h"
  34 #include "exceptions.h"
  35 #include "observer.h"
  36 #include "cli/cli-utils.h"
  37
  38 /* Local function declarations.  */
  39
  40 extern void _initialize_core (void);
  41
  42 /* You can have any number of hooks for `exec_file_command' command to
  43    call.  If there's only one hook, it is set in exec_file_display
  44    hook.  If there are two or more hooks, they are set in
  45    exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
  46    set to a function that calls all of them.  This extra complexity is
  47    needed to preserve compatibility with old code that assumed that
  48    only one hook could be set, and which called
  49    deprecated_exec_file_display_hook directly.  */
  50
  51 typedef void (*hook_type) (const char *);
  52
  53 hook_type deprecated_exec_file_display_hook;    /* The original hook.  */
  54 static hook_type *exec_file_extra_hooks;        /* Array of additional
  55                                                    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
  62 /* corelow.c target.  It is never NULL after GDB initialization.  */
  63
  64 struct target_ops *core_target;
  65 \f
  66
  67 /* Backward compatability with old way of specifying core files.  */
  68
  69 void
  70 core_file_command (char *filename, int from_tty)
  71 {
  72   dont_repeat ();               /* Either way, seems bogus.  */
  73
  74   gdb_assert (core_target != NULL);
  75
  76   if (!filename)
  77     (core_target->to_detach) (core_target, filename, from_tty);
  78   else
  79     (core_target->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 (const 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) (const 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
 111              array.  */
 112           exec_file_extra_hooks = (hook_type *)
 113             xmalloc (sizeof (hook_type));
 114           exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
 115           deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
 116           exec_file_hook_count = 1;
 117         }
 118
 119       /* Grow the hook array by one and add the new hook to the end.
 120          Yes, it's inefficient to grow it by one each time but since
 121          this is hardly ever called it's not a big deal.  */
 122       exec_file_hook_count++;
 123       new_array = (hook_type *)
 124         xrealloc (exec_file_extra_hooks,
 125                   exec_file_hook_count * sizeof (hook_type));
 126       exec_file_extra_hooks = new_array;
 127       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
 128     }
 129   else
 130     deprecated_exec_file_display_hook = hook;
 131 }
 132
 133 void
 134 reopen_exec_file (void)
 135 {
 136   char *filename;
 137   int res;
 138   struct stat st;
 139   struct cleanup *cleanups;
 140
 141   /* Don't do anything if there isn't an exec file.  */
 142   if (exec_bfd == NULL)
 143     return;
 144
 145   /* If the timestamp of the exec file has changed, reopen it.  */
 146   filename = xstrdup (bfd_get_filename (exec_bfd));
 147   cleanups = make_cleanup (xfree, filename);
 148   res = stat (filename, &st);
 149
 150   if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
 151     exec_file_attach (filename, 0);
 152   else
 153     /* If we accessed the file since last opening it, close it now;
 154        this stops GDB from holding the executable open after it
 155        exits.  */
 156     bfd_cache_close_all ();
 157
 158   do_cleanups (cleanups);
 159 }
 160 \f
 161 /* If we have both a core file and an exec file,
 162    print a warning if they don't go together.  */
 163
 164 void
 165 validate_files (void)
 166 {
 167   if (exec_bfd && core_bfd)
 168     {
 169       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 170         warning (_("core file may not match specified executable file."));
 171       else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
 172         warning (_("exec file is newer than core file."));
 173     }
 174 }
 175
 176 /* Return the name of the executable file as a string.
 177    ERR nonzero means get error if there is none specified;
 178    otherwise return 0 in that case.  */
 179
 180 char *
 181 get_exec_file (int err)
 182 {
 183   if (exec_filename)
 184     return exec_filename;
 185   if (!err)
 186     return NULL;
 187
 188   error (_("No executable file specified.\n\
 189 Use the \"file\" or \"exec-file\" command."));
 190   return NULL;
 191 }
 192 \f
 193
 194 char *
 195 memory_error_message (enum target_xfer_status err,
 196                       struct gdbarch *gdbarch, CORE_ADDR memaddr)
 197 {
 198   switch (err)
 199     {
 200     case TARGET_XFER_E_IO:
 201       /* Actually, address between memaddr and memaddr + len was out of
 202          bounds.  */
 203       return xstrprintf (_("Cannot access memory at address %s"),
 204                          paddress (gdbarch, memaddr));
 205     case TARGET_XFER_UNAVAILABLE:
 206       return xstrprintf (_("Memory at address %s unavailable."),
 207                          paddress (gdbarch, memaddr));
 208     default:
 209       internal_error (__FILE__, __LINE__,
 210                       "unhandled target_xfer_status: %s (%s)",
 211                       target_xfer_status_to_string (err),
 212                       plongest (err));
 213     }
 214 }
 215
 216 /* Report a memory error by throwing a suitable exception.  */
 217
 218 void
 219 memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
 220 {
 221   char *str;
 222   enum errors exception = GDB_NO_ERROR;
 223
 224   /* Build error string.  */
 225   str = memory_error_message (err, target_gdbarch (), memaddr);
 226   make_cleanup (xfree, str);
 227
 228   /* Choose the right error to throw.  */
 229   switch (err)
 230     {
 231     case TARGET_XFER_E_IO:
 232       exception = MEMORY_ERROR;
 233       break;
 234     case TARGET_XFER_UNAVAILABLE:
 235       exception = NOT_AVAILABLE_ERROR;
 236       break;
 237     }
 238
 239   /* Throw it.  */
 240   throw_error (exception, ("%s"), str);
 241 }
 242
 243 /* Same as target_read_memory, but report an error if can't read.  */
 244
 245 void
 246 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 247 {
 248   ULONGEST xfered = 0;
 249
 250   while (xfered < len)
 251     {
 252       enum target_xfer_status status;
 253       ULONGEST xfered_len;
 254
 255       status = target_xfer_partial (current_target.beneath,
 256                                     TARGET_OBJECT_MEMORY, NULL,
 257                                     myaddr + xfered, NULL,
 258                                     memaddr + xfered, len - xfered,
 259                                     &xfered_len);
 260
 261       if (status != TARGET_XFER_OK)
 262         memory_error (status == TARGET_XFER_EOF ? TARGET_XFER_E_IO : status,
 263                       memaddr + xfered);
 264
 265       xfered += xfered_len;
 266       QUIT;
 267     }
 268 }
 269
 270 /* Same as target_read_stack, but report an error if can't read.  */
 271
 272 void
 273 read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 274 {
 275   int status;
 276
 277   status = target_read_stack (memaddr, myaddr, len);
 278   if (status != 0)
 279     memory_error (status, memaddr);
 280 }
 281
 282 /* Same as target_read_code, but report an error if can't read.  */
 283
 284 void
 285 read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 286 {
 287   int status;
 288
 289   status = target_read_code (memaddr, myaddr, len);
 290   if (status != 0)
 291     memory_error (status, memaddr);
 292 }
 293
 294 /* Argument / return result struct for use with
 295    do_captured_read_memory_integer().  MEMADDR and LEN are filled in
 296    by gdb_read_memory_integer().  RESULT is the contents that were
 297    successfully read from MEMADDR of length LEN.  */
 298
 299 struct captured_read_memory_integer_arguments
 300 {
 301   CORE_ADDR memaddr;
 302   int len;
 303   enum bfd_endian byte_order;
 304   LONGEST result;
 305 };
 306
 307 /* Helper function for gdb_read_memory_integer().  DATA must be a
 308    pointer to a captured_read_memory_integer_arguments struct.
 309    Return 1 if successful.  Note that the catch_errors() interface
 310    will return 0 if an error occurred while reading memory.  This
 311    choice of return code is so that we can distinguish between
 312    success and failure.  */
 313
 314 static int
 315 do_captured_read_memory_integer (void *data)
 316 {
 317   struct captured_read_memory_integer_arguments *args
 318     = (struct captured_read_memory_integer_arguments*) data;
 319   CORE_ADDR memaddr = args->memaddr;
 320   int len = args->len;
 321   enum bfd_endian byte_order = args->byte_order;
 322
 323   args->result = read_memory_integer (memaddr, len, byte_order);
 324
 325   return 1;
 326 }
 327
 328 /* Read memory at MEMADDR of length LEN and put the contents in
 329    RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
 330    if successful.  */
 331
 332 int
 333 safe_read_memory_integer (CORE_ADDR memaddr, int len,
 334                           enum bfd_endian byte_order,
 335                           LONGEST *return_value)
 336 {
 337   int status;
 338   struct captured_read_memory_integer_arguments args;
 339
 340   args.memaddr = memaddr;
 341   args.len = len;
 342   args.byte_order = byte_order;
 343
 344   status = catch_errors (do_captured_read_memory_integer, &args,
 345                          "", RETURN_MASK_ALL);
 346   if (status)
 347     *return_value = args.result;
 348
 349   return status;
 350 }
 351
 352 LONGEST
 353 read_memory_integer (CORE_ADDR memaddr, int len,
 354                      enum bfd_endian byte_order)
 355 {
 356   gdb_byte buf[sizeof (LONGEST)];
 357
 358   read_memory (memaddr, buf, len);
 359   return extract_signed_integer (buf, len, byte_order);
 360 }
 361
 362 ULONGEST
 363 read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
 364                               enum bfd_endian byte_order)
 365 {
 366   gdb_byte buf[sizeof (ULONGEST)];
 367
 368   read_memory (memaddr, buf, len);
 369   return extract_unsigned_integer (buf, len, byte_order);
 370 }
 371
 372 LONGEST
 373 read_code_integer (CORE_ADDR memaddr, int len,
 374                    enum bfd_endian byte_order)
 375 {
 376   gdb_byte buf[sizeof (LONGEST)];
 377
 378   read_code (memaddr, buf, len);
 379   return extract_signed_integer (buf, len, byte_order);
 380 }
 381
 382 ULONGEST
 383 read_code_unsigned_integer (CORE_ADDR memaddr, int len,
 384                             enum bfd_endian byte_order)
 385 {
 386   gdb_byte buf[sizeof (ULONGEST)];
 387
 388   read_code (memaddr, buf, len);
 389   return extract_unsigned_integer (buf, len, byte_order);
 390 }
 391
 392 void
 393 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 394 {
 395   char *cp;
 396   int i;
 397   int cnt;
 398
 399   cp = buffer;
 400   while (1)
 401     {
 402       if (cp - buffer >= max_len)
 403         {
 404           buffer[max_len - 1] = '\0';
 405           break;
 406         }
 407       cnt = max_len - (cp - buffer);
 408       if (cnt > 8)
 409         cnt = 8;
 410       read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
 411       for (i = 0; i < cnt && *cp; i++, cp++)
 412         ;                       /* null body */
 413
 414       if (i < cnt && !*cp)
 415         break;
 416     }
 417 }
 418
 419 CORE_ADDR
 420 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 421 {
 422   gdb_byte *buf = alloca (TYPE_LENGTH (type));
 423
 424   read_memory (addr, buf, TYPE_LENGTH (type));
 425   return extract_typed_address (buf, type);
 426 }
 427
 428 /* Same as target_write_memory, but report an error if can't
 429    write.  */
 430 void
 431 write_memory (CORE_ADDR memaddr,
 432               const bfd_byte *myaddr, ssize_t len)
 433 {
 434   int status;
 435
 436   status = target_write_memory (memaddr, myaddr, len);
 437   if (status != 0)
 438     memory_error (status, memaddr);
 439 }
 440
 441 /* Same as write_memory, but notify 'memory_changed' observers.  */
 442
 443 void
 444 write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
 445                                 ssize_t len)
 446 {
 447   write_memory (memaddr, myaddr, len);
 448   observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
 449 }
 450
 451 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
 452    integer.  */
 453 void
 454 write_memory_unsigned_integer (CORE_ADDR addr, int len,
 455                                enum bfd_endian byte_order,
 456                                ULONGEST value)
 457 {
 458   gdb_byte *buf = alloca (len);
 459
 460   store_unsigned_integer (buf, len, byte_order, value);
 461   write_memory (addr, buf, len);
 462 }
 463
 464 /* Store VALUE at ADDR in the inferior as a LEN-byte signed
 465    integer.  */
 466 void
 467 write_memory_signed_integer (CORE_ADDR addr, int len,
 468                              enum bfd_endian byte_order,
 469                              LONGEST value)
 470 {
 471   gdb_byte *buf = alloca (len);
 472
 473   store_signed_integer (buf, len, byte_order, value);
 474   write_memory (addr, buf, len);
 475 }
 476 \f
 477 /* The current default bfd target.  Points to storage allocated for
 478    gnutarget_string.  */
 479 char *gnutarget;
 480
 481 /* Same thing, except it is "auto" not NULL for the default case.  */
 482 static char *gnutarget_string;
 483 static void
 484 show_gnutarget_string (struct ui_file *file, int from_tty,
 485                        struct cmd_list_element *c,
 486                        const char *value)
 487 {
 488   fprintf_filtered (file,
 489                     _("The current BFD target is \"%s\".\n"), value);
 490 }
 491
 492 static void set_gnutarget_command (char *, int,
 493                                    struct cmd_list_element *);
 494
 495 static void
 496 set_gnutarget_command (char *ignore, int from_tty,
 497                        struct cmd_list_element *c)
 498 {
 499   char *gend = gnutarget_string + strlen (gnutarget_string);
 500
 501   gend = remove_trailing_whitespace (gnutarget_string, gend);
 502   *gend = '\0';
 503
 504   if (strcmp (gnutarget_string, "auto") == 0)
 505     gnutarget = NULL;
 506   else
 507     gnutarget = gnutarget_string;
 508 }
 509
 510 /* A completion function for "set gnutarget".  */
 511
 512 static VEC (char_ptr) *
 513 complete_set_gnutarget (struct cmd_list_element *cmd,
 514                         const char *text, const char *word)
 515 {
 516   static const char **bfd_targets;
 517
 518   if (bfd_targets == NULL)
 519     {
 520       int last;
 521
 522       bfd_targets = bfd_target_list ();
 523       for (last = 0; bfd_targets[last] != NULL; ++last)
 524         ;
 525
 526       bfd_targets = xrealloc (bfd_targets, (last + 2) * sizeof (const char **));
 527       bfd_targets[last] = "auto";
 528       bfd_targets[last + 1] = NULL;
 529     }
 530
 531   return complete_on_enum (bfd_targets, text, word);
 532 }
 533
 534 /* Set the gnutarget.  */
 535 void
 536 set_gnutarget (char *newtarget)
 537 {
 538   if (gnutarget_string != NULL)
 539     xfree (gnutarget_string);
 540   gnutarget_string = xstrdup (newtarget);
 541   set_gnutarget_command (NULL, 0, NULL);
 542 }
 543
 544 void
 545 _initialize_core (void)
 546 {
 547   struct cmd_list_element *c;
 548
 549   c = add_cmd ("core-file", class_files, core_file_command, _("\
 550 Use FILE as core dump for examining memory and registers.\n\
 551 No arg means have no core file.  This command has been superseded by the\n\
 552 `target core' and `detach' commands."), &cmdlist);
 553   set_cmd_completer (c, filename_completer);
 554
 555
 556   c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
 557                                        &gnutarget_string, _("\
 558 Set the current BFD target."), _("\
 559 Show the current BFD target."), _("\
 560 Use `set gnutarget auto' to specify automatic detection."),
 561                                        set_gnutarget_command,
 562                                        show_gnutarget_string,
 563                                        &setlist, &showlist);
 564   set_cmd_completer (c, complete_set_gnutarget);
 565
 566   add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
 567
 568   if (getenv ("GNUTARGET"))
 569     set_gnutarget (getenv ("GNUTARGET"));
 570   else
 571     set_gnutarget ("auto");
 572 }