gdb/corefile.c

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