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