gdb/corefile.c

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