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 /* Read memory at MEMADDR of length LEN and put the contents in
 294    RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
 295    if successful.  */
 296
 297 int
 298 safe_read_memory_integer (CORE_ADDR memaddr, int len,
 299                           enum bfd_endian byte_order,
 300                           LONGEST *return_value)
 301 {
 302   gdb_byte buf[sizeof (LONGEST)];
 303
 304   if (target_read_memory (memaddr, buf, len))
 305     return 0;
 306
 307   *return_value = extract_signed_integer (buf, len, byte_order);
 308   return 1;
 309 }
 310
 311 LONGEST
 312 read_memory_integer (CORE_ADDR memaddr, int len,
 313                      enum bfd_endian byte_order)
 314 {
 315   gdb_byte buf[sizeof (LONGEST)];
 316
 317   read_memory (memaddr, buf, len);
 318   return extract_signed_integer (buf, len, byte_order);
 319 }
 320
 321 ULONGEST
 322 read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
 323                               enum bfd_endian byte_order)
 324 {
 325   gdb_byte buf[sizeof (ULONGEST)];
 326
 327   read_memory (memaddr, buf, len);
 328   return extract_unsigned_integer (buf, len, byte_order);
 329 }
 330
 331 LONGEST
 332 read_code_integer (CORE_ADDR memaddr, int len,
 333                    enum bfd_endian byte_order)
 334 {
 335   gdb_byte buf[sizeof (LONGEST)];
 336
 337   read_code (memaddr, buf, len);
 338   return extract_signed_integer (buf, len, byte_order);
 339 }
 340
 341 ULONGEST
 342 read_code_unsigned_integer (CORE_ADDR memaddr, int len,
 343                             enum bfd_endian byte_order)
 344 {
 345   gdb_byte buf[sizeof (ULONGEST)];
 346
 347   read_code (memaddr, buf, len);
 348   return extract_unsigned_integer (buf, len, byte_order);
 349 }
 350
 351 void
 352 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 353 {
 354   char *cp;
 355   int i;
 356   int cnt;
 357
 358   cp = buffer;
 359   while (1)
 360     {
 361       if (cp - buffer >= max_len)
 362         {
 363           buffer[max_len - 1] = '\0';
 364           break;
 365         }
 366       cnt = max_len - (cp - buffer);
 367       if (cnt > 8)
 368         cnt = 8;
 369       read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
 370       for (i = 0; i < cnt && *cp; i++, cp++)
 371         ;                       /* null body */
 372
 373       if (i < cnt && !*cp)
 374         break;
 375     }
 376 }
 377
 378 CORE_ADDR
 379 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 380 {
 381   gdb_byte *buf = alloca (TYPE_LENGTH (type));
 382
 383   read_memory (addr, buf, TYPE_LENGTH (type));
 384   return extract_typed_address (buf, type);
 385 }
 386
 387 /* Same as target_write_memory, but report an error if can't
 388    write.  */
 389 void
 390 write_memory (CORE_ADDR memaddr,
 391               const bfd_byte *myaddr, ssize_t len)
 392 {
 393   int status;
 394
 395   status = target_write_memory (memaddr, myaddr, len);
 396   if (status != 0)
 397     memory_error (status, memaddr);
 398 }
 399
 400 /* Same as write_memory, but notify 'memory_changed' observers.  */
 401
 402 void
 403 write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
 404                                 ssize_t len)
 405 {
 406   write_memory (memaddr, myaddr, len);
 407   observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
 408 }
 409
 410 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
 411    integer.  */
 412 void
 413 write_memory_unsigned_integer (CORE_ADDR addr, int len,
 414                                enum bfd_endian byte_order,
 415                                ULONGEST value)
 416 {
 417   gdb_byte *buf = alloca (len);
 418
 419   store_unsigned_integer (buf, len, byte_order, value);
 420   write_memory (addr, buf, len);
 421 }
 422
 423 /* Store VALUE at ADDR in the inferior as a LEN-byte signed
 424    integer.  */
 425 void
 426 write_memory_signed_integer (CORE_ADDR addr, int len,
 427                              enum bfd_endian byte_order,
 428                              LONGEST value)
 429 {
 430   gdb_byte *buf = alloca (len);
 431
 432   store_signed_integer (buf, len, byte_order, value);
 433   write_memory (addr, buf, len);
 434 }
 435 \f
 436 /* The current default bfd target.  Points to storage allocated for
 437    gnutarget_string.  */
 438 char *gnutarget;
 439
 440 /* Same thing, except it is "auto" not NULL for the default case.  */
 441 static char *gnutarget_string;
 442 static void
 443 show_gnutarget_string (struct ui_file *file, int from_tty,
 444                        struct cmd_list_element *c,
 445                        const char *value)
 446 {
 447   fprintf_filtered (file,
 448                     _("The current BFD target is \"%s\".\n"), value);
 449 }
 450
 451 static void set_gnutarget_command (char *, int,
 452                                    struct cmd_list_element *);
 453
 454 static void
 455 set_gnutarget_command (char *ignore, int from_tty,
 456                        struct cmd_list_element *c)
 457 {
 458   char *gend = gnutarget_string + strlen (gnutarget_string);
 459
 460   gend = remove_trailing_whitespace (gnutarget_string, gend);
 461   *gend = '\0';
 462
 463   if (strcmp (gnutarget_string, "auto") == 0)
 464     gnutarget = NULL;
 465   else
 466     gnutarget = gnutarget_string;
 467 }
 468
 469 /* A completion function for "set gnutarget".  */
 470
 471 static VEC (char_ptr) *
 472 complete_set_gnutarget (struct cmd_list_element *cmd,
 473                         const char *text, const char *word)
 474 {
 475   static const char **bfd_targets;
 476
 477   if (bfd_targets == NULL)
 478     {
 479       int last;
 480
 481       bfd_targets = bfd_target_list ();
 482       for (last = 0; bfd_targets[last] != NULL; ++last)
 483         ;
 484
 485       bfd_targets = xrealloc (bfd_targets, (last + 2) * sizeof (const char **));
 486       bfd_targets[last] = "auto";
 487       bfd_targets[last + 1] = NULL;
 488     }
 489
 490   return complete_on_enum (bfd_targets, text, word);
 491 }
 492
 493 /* Set the gnutarget.  */
 494 void
 495 set_gnutarget (char *newtarget)
 496 {
 497   if (gnutarget_string != NULL)
 498     xfree (gnutarget_string);
 499   gnutarget_string = xstrdup (newtarget);
 500   set_gnutarget_command (NULL, 0, NULL);
 501 }
 502
 503 void
 504 _initialize_core (void)
 505 {
 506   struct cmd_list_element *c;
 507
 508   c = add_cmd ("core-file", class_files, core_file_command, _("\
 509 Use FILE as core dump for examining memory and registers.\n\
 510 No arg means have no core file.  This command has been superseded by the\n\
 511 `target core' and `detach' commands."), &cmdlist);
 512   set_cmd_completer (c, filename_completer);
 513
 514
 515   c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
 516                                        &gnutarget_string, _("\
 517 Set the current BFD target."), _("\
 518 Show the current BFD target."), _("\
 519 Use `set gnutarget auto' to specify automatic detection."),
 520                                        set_gnutarget_command,
 521                                        show_gnutarget_string,
 522                                        &setlist, &showlist);
 523   set_cmd_completer (c, complete_set_gnutarget);
 524
 525   add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
 526
 527   if (getenv ("GNUTARGET"))
 528     set_gnutarget (getenv ("GNUTARGET"));
 529   else
 530     set_gnutarget ("auto");
 531 }