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