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