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