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