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