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