gdb/corefile.c

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