gdb/corefile.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2
   3    Copyright (C) 1986-2018 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 "observable.h"
  34 #include "cli/cli-utils.h"
  35
  36 /* You can have any number of hooks for `exec_file_command' command to
  37    call.  If there's only one hook, it is set in exec_file_display
  38    hook.  If there are two or more hooks, they are set in
  39    exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
  40    set to a function that calls all of them.  This extra complexity is
  41    needed to preserve compatibility with old code that assumed that
  42    only one hook could be set, and which called
  43    deprecated_exec_file_display_hook directly.  */
  44
  45 typedef void (*hook_type) (const char *);
  46
  47 hook_type deprecated_exec_file_display_hook;    /* The original hook.  */
  48 static hook_type *exec_file_extra_hooks;        /* Array of additional
  49                                                    hooks.  */
  50 static int exec_file_hook_count = 0;            /* Size of array.  */
  51
  52 /* Binary file diddling handle for the core file.  */
  53
  54 bfd *core_bfd = NULL;
  55
  56 \f
  57
  58 /* Backward compatability with old way of specifying core files.  */
  59
  60 void
  61 core_file_command (const char *filename, int from_tty)
  62 {
  63   dont_repeat ();               /* Either way, seems bogus.  */
  64
  65   gdb_assert (the_core_target != NULL);
  66
  67   if (!filename)
  68     the_core_target->detach (current_inferior (), from_tty);
  69   else
  70     the_core_target->open (filename, from_tty);
  71 }
  72 \f
  73
  74 /* If there are two or more functions that wish to hook into
  75    exec_file_command, this function will call all of the hook
  76    functions.  */
  77
  78 static void
  79 call_extra_exec_file_hooks (const char *filename)
  80 {
  81   int i;
  82
  83   for (i = 0; i < exec_file_hook_count; i++)
  84     (*exec_file_extra_hooks[i]) (filename);
  85 }
  86
  87 /* Call this to specify the hook for exec_file_command to call back.
  88    This is called from the x-window display code.  */
  89
  90 void
  91 specify_exec_file_hook (void (*hook) (const char *))
  92 {
  93   hook_type *new_array;
  94
  95   if (deprecated_exec_file_display_hook != NULL)
  96     {
  97       /* There's already a hook installed.  Arrange to have both it
  98          and the subsequent hooks called.  */
  99       if (exec_file_hook_count == 0)
 100         {
 101           /* If this is the first extra hook, initialize the hook
 102              array.  */
 103           exec_file_extra_hooks = XNEW (hook_type);
 104           exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
 105           deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
 106           exec_file_hook_count = 1;
 107         }
 108
 109       /* Grow the hook array by one and add the new hook to the end.
 110          Yes, it's inefficient to grow it by one each time but since
 111          this is hardly ever called it's not a big deal.  */
 112       exec_file_hook_count++;
 113       new_array = (hook_type *)
 114         xrealloc (exec_file_extra_hooks,
 115                   exec_file_hook_count * sizeof (hook_type));
 116       exec_file_extra_hooks = new_array;
 117       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
 118     }
 119   else
 120     deprecated_exec_file_display_hook = hook;
 121 }
 122
 123 void
 124 reopen_exec_file (void)
 125 {
 126   int res;
 127   struct stat st;
 128
 129   /* Don't do anything if there isn't an exec file.  */
 130   if (exec_bfd == NULL)
 131     return;
 132
 133   /* If the timestamp of the exec file has changed, reopen it.  */
 134   std::string filename = bfd_get_filename (exec_bfd);
 135   res = stat (filename.c_str (), &st);
 136
 137   if (res == 0 && exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
 138     exec_file_attach (filename.c_str (), 0);
 139   else
 140     /* If we accessed the file since last opening it, close it now;
 141        this stops GDB from holding the executable open after it
 142        exits.  */
 143     bfd_cache_close_all ();
 144 }
 145 \f
 146 /* If we have both a core file and an exec file,
 147    print a warning if they don't go together.  */
 148
 149 void
 150 validate_files (void)
 151 {
 152   if (exec_bfd && core_bfd)
 153     {
 154       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 155         warning (_("core file may not match specified executable file."));
 156       else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
 157         warning (_("exec file is newer than core file."));
 158     }
 159 }
 160
 161 /* See common/common-inferior.h.  */
 162
 163 char *
 164 get_exec_file (int err)
 165 {
 166   if (exec_filename)
 167     return exec_filename;
 168   if (!err)
 169     return NULL;
 170
 171   error (_("No executable file specified.\n\
 172 Use the \"file\" or \"exec-file\" command."));
 173   return NULL;
 174 }
 175 \f
 176
 177 std::string
 178 memory_error_message (enum target_xfer_status err,
 179                       struct gdbarch *gdbarch, CORE_ADDR memaddr)
 180 {
 181   switch (err)
 182     {
 183     case TARGET_XFER_E_IO:
 184       /* Actually, address between memaddr and memaddr + len was out of
 185          bounds.  */
 186       return string_printf (_("Cannot access memory at address %s"),
 187                             paddress (gdbarch, memaddr));
 188     case TARGET_XFER_UNAVAILABLE:
 189       return string_printf (_("Memory at address %s unavailable."),
 190                             paddress (gdbarch, memaddr));
 191     default:
 192       internal_error (__FILE__, __LINE__,
 193                       "unhandled target_xfer_status: %s (%s)",
 194                       target_xfer_status_to_string (err),
 195                       plongest (err));
 196     }
 197 }
 198
 199 /* Report a memory error by throwing a suitable exception.  */
 200
 201 void
 202 memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
 203 {
 204   enum errors exception = GDB_NO_ERROR;
 205
 206   /* Build error string.  */
 207   std::string str = memory_error_message (err, target_gdbarch (), memaddr);
 208
 209   /* Choose the right error to throw.  */
 210   switch (err)
 211     {
 212     case TARGET_XFER_E_IO:
 213       exception = MEMORY_ERROR;
 214       break;
 215     case TARGET_XFER_UNAVAILABLE:
 216       exception = NOT_AVAILABLE_ERROR;
 217       break;
 218     }
 219
 220   /* Throw it.  */
 221   throw_error (exception, ("%s"), str.c_str ());
 222 }
 223
 224 /* Helper function.  */
 225
 226 static void
 227 read_memory_object (enum target_object object, CORE_ADDR memaddr,
 228                     gdb_byte *myaddr, ssize_t len)
 229 {
 230   ULONGEST xfered = 0;
 231
 232   while (xfered < len)
 233     {
 234       enum target_xfer_status status;
 235       ULONGEST xfered_len;
 236
 237       status = target_xfer_partial (target_stack, object, NULL,
 238                                     myaddr + xfered, NULL,
 239                                     memaddr + xfered, len - xfered,
 240                                     &xfered_len);
 241
 242       if (status != TARGET_XFER_OK)
 243         memory_error (status == TARGET_XFER_EOF ? TARGET_XFER_E_IO : status,
 244                       memaddr + xfered);
 245
 246       xfered += xfered_len;
 247       QUIT;
 248     }
 249 }
 250
 251 /* Same as target_read_memory, but report an error if can't read.  */
 252
 253 void
 254 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 255 {
 256   read_memory_object (TARGET_OBJECT_MEMORY, memaddr, myaddr, len);
 257 }
 258
 259 /* Same as target_read_stack, but report an error if can't read.  */
 260
 261 void
 262 read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 263 {
 264   read_memory_object (TARGET_OBJECT_STACK_MEMORY, memaddr, myaddr, len);
 265 }
 266
 267 /* Same as target_read_code, but report an error if can't read.  */
 268
 269 void
 270 read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 271 {
 272   read_memory_object (TARGET_OBJECT_CODE_MEMORY, memaddr, myaddr, len);
 273 }
 274
 275 /* Read memory at MEMADDR of length LEN and put the contents in
 276    RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
 277    if successful.  */
 278
 279 int
 280 safe_read_memory_integer (CORE_ADDR memaddr, int len,
 281                           enum bfd_endian byte_order,
 282                           LONGEST *return_value)
 283 {
 284   gdb_byte buf[sizeof (LONGEST)];
 285
 286   if (target_read_memory (memaddr, buf, len))
 287     return 0;
 288
 289   *return_value = extract_signed_integer (buf, len, byte_order);
 290   return 1;
 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_unsigned_integer (CORE_ADDR memaddr, int len,
 299                                    enum bfd_endian byte_order,
 300                                    ULONGEST *return_value)
 301 {
 302   gdb_byte buf[sizeof (ULONGEST)];
 303
 304   if (target_read_memory (memaddr, buf, len))
 305     return 0;
 306
 307   *return_value = extract_unsigned_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 = (gdb_byte *) alloca (TYPE_LENGTH (type));
 382
 383   read_memory (addr, buf, TYPE_LENGTH (type));
 384   return extract_typed_address (buf, type);
 385 }
 386
 387 /* See gdbcore.h.  */
 388
 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 (TARGET_XFER_E_IO, 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   gdb::observers::memory_changed.notify (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 = (gdb_byte *) 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 = (gdb_byte *) 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
 452 set_gnutarget_command (const char *ignore, int from_tty,
 453                        struct cmd_list_element *c)
 454 {
 455   char *gend = gnutarget_string + strlen (gnutarget_string);
 456
 457   gend = remove_trailing_whitespace (gnutarget_string, gend);
 458   *gend = '\0';
 459
 460   if (strcmp (gnutarget_string, "auto") == 0)
 461     gnutarget = NULL;
 462   else
 463     gnutarget = gnutarget_string;
 464 }
 465
 466 /* A completion function for "set gnutarget".  */
 467
 468 static void
 469 complete_set_gnutarget (struct cmd_list_element *cmd,
 470                         completion_tracker &tracker,
 471                         const char *text, const char *word)
 472 {
 473   static const char **bfd_targets;
 474
 475   if (bfd_targets == NULL)
 476     {
 477       int last;
 478
 479       bfd_targets = bfd_target_list ();
 480       for (last = 0; bfd_targets[last] != NULL; ++last)
 481         ;
 482
 483       bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2);
 484       bfd_targets[last] = "auto";
 485       bfd_targets[last + 1] = NULL;
 486     }
 487
 488   complete_on_enum (tracker, bfd_targets, text, word);
 489 }
 490
 491 /* Set the gnutarget.  */
 492 void
 493 set_gnutarget (const char *newtarget)
 494 {
 495   if (gnutarget_string != NULL)
 496     xfree (gnutarget_string);
 497   gnutarget_string = xstrdup (newtarget);
 498   set_gnutarget_command (NULL, 0, NULL);
 499 }
 500
 501 void
 502 _initialize_core (void)
 503 {
 504   struct cmd_list_element *c;
 505
 506   c = add_cmd ("core-file", class_files, core_file_command, _("\
 507 Use FILE as core dump for examining memory and registers.\n\
 508 No arg means have no core file.  This command has been superseded by the\n\
 509 `target core' and `detach' commands."), &cmdlist);
 510   set_cmd_completer (c, filename_completer);
 511
 512
 513   c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
 514                                        &gnutarget_string, _("\
 515 Set the current BFD target."), _("\
 516 Show the current BFD target."), _("\
 517 Use `set gnutarget auto' to specify automatic detection."),
 518                                        set_gnutarget_command,
 519                                        show_gnutarget_string,
 520                                        &setlist, &showlist);
 521   set_cmd_completer (c, complete_set_gnutarget);
 522
 523   add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
 524
 525   if (getenv ("GNUTARGET"))
 526     set_gnutarget (getenv ("GNUTARGET"));
 527   else
 528     set_gnutarget ("auto");
 529 }