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 void
 332 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 333 {
 334   char *cp;
 335   int i;
 336   int cnt;
 337
 338   cp = buffer;
 339   while (1)
 340     {
 341       if (cp - buffer >= max_len)
 342         {
 343           buffer[max_len - 1] = '\0';
 344           break;
 345         }
 346       cnt = max_len - (cp - buffer);
 347       if (cnt > 8)
 348         cnt = 8;
 349       read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
 350       for (i = 0; i < cnt && *cp; i++, cp++)
 351         ;                       /* null body */
 352
 353       if (i < cnt && !*cp)
 354         break;
 355     }
 356 }
 357
 358 CORE_ADDR
 359 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 360 {
 361   gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
 362
 363   read_memory (addr, buf, TYPE_LENGTH (type));
 364   return extract_typed_address (buf, type);
 365 }
 366
 367 /* See gdbcore.h.  */
 368
 369 void
 370 write_memory (CORE_ADDR memaddr,
 371               const bfd_byte *myaddr, ssize_t len)
 372 {
 373   int status;
 374
 375   status = target_write_memory (memaddr, myaddr, len);
 376   if (status != 0)
 377     memory_error (TARGET_XFER_E_IO, memaddr);
 378 }
 379
 380 /* Same as write_memory, but notify 'memory_changed' observers.  */
 381
 382 void
 383 write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
 384                                 ssize_t len)
 385 {
 386   write_memory (memaddr, myaddr, len);
 387   gdb::observers::memory_changed.notify (current_inferior (), memaddr, len, myaddr);
 388 }
 389
 390 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
 391    integer.  */
 392 void
 393 write_memory_unsigned_integer (CORE_ADDR addr, int len,
 394                                enum bfd_endian byte_order,
 395                                ULONGEST value)
 396 {
 397   gdb_byte *buf = (gdb_byte *) alloca (len);
 398
 399   store_unsigned_integer (buf, len, byte_order, value);
 400   write_memory (addr, buf, len);
 401 }
 402
 403 /* Store VALUE at ADDR in the inferior as a LEN-byte signed
 404    integer.  */
 405 void
 406 write_memory_signed_integer (CORE_ADDR addr, int len,
 407                              enum bfd_endian byte_order,
 408                              LONGEST value)
 409 {
 410   gdb_byte *buf = (gdb_byte *) alloca (len);
 411
 412   store_signed_integer (buf, len, byte_order, value);
 413   write_memory (addr, buf, len);
 414 }
 415 \f
 416 /* The current default bfd target.  Points to storage allocated for
 417    gnutarget_string.  */
 418 const char *gnutarget;
 419
 420 /* Same thing, except it is "auto" not NULL for the default case.  */
 421 static char *gnutarget_string;
 422 static void
 423 show_gnutarget_string (struct ui_file *file, int from_tty,
 424                        struct cmd_list_element *c,
 425                        const char *value)
 426 {
 427   fprintf_filtered (file,
 428                     _("The current BFD target is \"%s\".\n"), value);
 429 }
 430
 431 static void
 432 set_gnutarget_command (const char *ignore, int from_tty,
 433                        struct cmd_list_element *c)
 434 {
 435   char *gend = gnutarget_string + strlen (gnutarget_string);
 436
 437   gend = remove_trailing_whitespace (gnutarget_string, gend);
 438   *gend = '\0';
 439
 440   if (strcmp (gnutarget_string, "auto") == 0)
 441     gnutarget = NULL;
 442   else
 443     gnutarget = gnutarget_string;
 444 }
 445
 446 /* A completion function for "set gnutarget".  */
 447
 448 static void
 449 complete_set_gnutarget (struct cmd_list_element *cmd,
 450                         completion_tracker &tracker,
 451                         const char *text, const char *word)
 452 {
 453   static const char **bfd_targets;
 454
 455   if (bfd_targets == NULL)
 456     {
 457       int last;
 458
 459       bfd_targets = bfd_target_list ();
 460       for (last = 0; bfd_targets[last] != NULL; ++last)
 461         ;
 462
 463       bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2);
 464       bfd_targets[last] = "auto";
 465       bfd_targets[last + 1] = NULL;
 466     }
 467
 468   complete_on_enum (tracker, bfd_targets, text, word);
 469 }
 470
 471 /* Set the gnutarget.  */
 472 void
 473 set_gnutarget (const char *newtarget)
 474 {
 475   xfree (gnutarget_string);
 476   gnutarget_string = xstrdup (newtarget);
 477   set_gnutarget_command (NULL, 0, NULL);
 478 }
 479
 480 void _initialize_core ();
 481 void
 482 _initialize_core ()
 483 {
 484   struct cmd_list_element *c;
 485
 486   c = add_cmd ("core-file", class_files, core_file_command, _("\
 487 Use FILE as core dump for examining memory and registers.\n\
 488 Usage: core-file FILE\n\
 489 No arg means have no core file.  This command has been superseded by the\n\
 490 `target core' and `detach' commands."), &cmdlist);
 491   set_cmd_completer (c, filename_completer);
 492
 493
 494   c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
 495                                        &gnutarget_string, _("\
 496 Set the current BFD target."), _("\
 497 Show the current BFD target."), _("\
 498 Use `set gnutarget auto' to specify automatic detection."),
 499                                        set_gnutarget_command,
 500                                        show_gnutarget_string,
 501                                        &setlist, &showlist);
 502   set_cmd_completer (c, complete_set_gnutarget);
 503
 504   add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
 505
 506   if (getenv ("GNUTARGET"))
 507     set_gnutarget (getenv ("GNUTARGET"));
 508   else
 509     set_gnutarget ("auto");
 510 }