gdb/corefile.c

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