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