gdb/corefile.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2
   3    Copyright (C) 1986-2024 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 #include "interps.h"
  37
  38 /* You can have any number of hooks for `exec_file_command' command to
  39    call.  If there's only one hook, it is set in exec_file_display
  40    hook.  If there are two or more hooks, they are set in
  41    exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
  42    set to a function that calls all of them.  This extra complexity is
  43    needed to preserve compatibility with old code that assumed that
  44    only one hook could be set, and which called
  45    deprecated_exec_file_display_hook directly.  */
  46
  47 typedef void (*hook_type) (const char *);
  48
  49 hook_type deprecated_exec_file_display_hook;    /* The original hook.  */
  50 static hook_type *exec_file_extra_hooks;        /* Array of additional
  51                                                    hooks.  */
  52 static int exec_file_hook_count = 0;            /* Size of array.  */
  53
  54 \f
  55
  56 /* If there are two or more functions that wish to hook into
  57    exec_file_command, this function will call all of the hook
  58    functions.  */
  59
  60 static void
  61 call_extra_exec_file_hooks (const char *filename)
  62 {
  63   int i;
  64
  65   for (i = 0; i < exec_file_hook_count; i++)
  66     (*exec_file_extra_hooks[i]) (filename);
  67 }
  68
  69 /* Call this to specify the hook for exec_file_command to call back.
  70    This is called from the x-window display code.  */
  71
  72 void
  73 specify_exec_file_hook (void (*hook) (const char *))
  74 {
  75   hook_type *new_array;
  76
  77   if (deprecated_exec_file_display_hook != NULL)
  78     {
  79       /* There's already a hook installed.  Arrange to have both it
  80          and the subsequent hooks called.  */
  81       if (exec_file_hook_count == 0)
  82         {
  83           /* If this is the first extra hook, initialize the hook
  84              array.  */
  85           exec_file_extra_hooks = XNEW (hook_type);
  86           exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
  87           deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
  88           exec_file_hook_count = 1;
  89         }
  90
  91       /* Grow the hook array by one and add the new hook to the end.
  92          Yes, it's inefficient to grow it by one each time but since
  93          this is hardly ever called it's not a big deal.  */
  94       exec_file_hook_count++;
  95       new_array = (hook_type *)
  96         xrealloc (exec_file_extra_hooks,
  97                   exec_file_hook_count * sizeof (hook_type));
  98       exec_file_extra_hooks = new_array;
  99       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
 100     }
 101   else
 102     deprecated_exec_file_display_hook = hook;
 103 }
 104
 105 void
 106 reopen_exec_file (void)
 107 {
 108   bfd *exec_bfd = current_program_space->exec_bfd ();
 109
 110   /* Don't do anything if there isn't an exec file.  */
 111   if (exec_bfd == nullptr)
 112     return;
 113
 114   /* The main executable can't be an in-memory BFD object.  If it was then
 115      the use of bfd_stat below would not work as expected.  */
 116   gdb_assert ((exec_bfd->flags & BFD_IN_MEMORY) == 0);
 117
 118   /* If the timestamp of the exec file has changed, reopen it.  */
 119   struct stat st;
 120   int res = bfd_stat (exec_bfd, &st);
 121
 122   if (res == 0
 123       && current_program_space->ebfd_mtime != 0
 124       && current_program_space->ebfd_mtime != st.st_mtime)
 125     exec_file_attach (bfd_get_filename (exec_bfd), 0);
 126 }
 127 \f
 128 /* If we have both a core file and an exec file,
 129    print a warning if they don't go together.  */
 130
 131 void
 132 validate_files (void)
 133 {
 134   if (current_program_space->exec_bfd () && core_bfd)
 135     {
 136       if (!core_file_matches_executable_p (core_bfd,
 137                                            current_program_space->exec_bfd ()))
 138         warning (_("core file may not match specified executable file."));
 139       else if (bfd_get_mtime (current_program_space->exec_bfd ())
 140                > bfd_get_mtime (core_bfd))
 141         warning (_("exec file is newer than core file."));
 142     }
 143 }
 144
 145 /* See gdbsupport/common-inferior.h.  */
 146
 147 const char *
 148 get_exec_file (int err)
 149 {
 150   if (current_program_space->exec_filename != nullptr)
 151     return current_program_space->exec_filename.get ();
 152   if (!err)
 153     return NULL;
 154
 155   error (_("No executable file specified.\n\
 156 Use the \"file\" or \"exec-file\" command."));
 157 }
 158 \f
 159
 160 std::string
 161 memory_error_message (enum target_xfer_status err,
 162                       struct gdbarch *gdbarch, CORE_ADDR memaddr)
 163 {
 164   switch (err)
 165     {
 166     case TARGET_XFER_E_IO:
 167       /* Actually, address between memaddr and memaddr + len was out of
 168          bounds.  */
 169       return string_printf (_("Cannot access memory at address %s"),
 170                             paddress (gdbarch, memaddr));
 171     case TARGET_XFER_UNAVAILABLE:
 172       return string_printf (_("Memory at address %s unavailable."),
 173                             paddress (gdbarch, memaddr));
 174     default:
 175       internal_error ("unhandled target_xfer_status: %s (%s)",
 176                       target_xfer_status_to_string (err),
 177                       plongest (err));
 178     }
 179 }
 180
 181 /* Report a memory error by throwing a suitable exception.  */
 182
 183 void
 184 memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
 185 {
 186   enum errors exception = GDB_NO_ERROR;
 187
 188   /* Build error string.  */
 189   std::string str
 190     = memory_error_message (err, current_inferior ()->arch (), 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 /* Notify interpreters and observers that INF's memory was changed.  */
 357
 358 static void
 359 notify_memory_changed (inferior *inf, CORE_ADDR addr, ssize_t len,
 360                        const bfd_byte *data)
 361 {
 362   interps_notify_memory_changed (inf, addr, len, data);
 363   gdb::observers::memory_changed.notify (inf, addr, len, data);
 364 }
 365
 366 /* Same as write_memory, but notify 'memory_changed' observers.  */
 367
 368 void
 369 write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
 370                                 ssize_t len)
 371 {
 372   write_memory (memaddr, myaddr, len);
 373   notify_memory_changed (current_inferior (), memaddr, len, myaddr);
 374 }
 375
 376 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
 377    integer.  */
 378 void
 379 write_memory_unsigned_integer (CORE_ADDR addr, int len,
 380                                enum bfd_endian byte_order,
 381                                ULONGEST value)
 382 {
 383   gdb_byte *buf = (gdb_byte *) alloca (len);
 384
 385   store_unsigned_integer (buf, len, byte_order, value);
 386   write_memory (addr, buf, len);
 387 }
 388
 389 /* Store VALUE at ADDR in the inferior as a LEN-byte signed
 390    integer.  */
 391 void
 392 write_memory_signed_integer (CORE_ADDR addr, int len,
 393                              enum bfd_endian byte_order,
 394                              LONGEST value)
 395 {
 396   gdb_byte *buf = (gdb_byte *) alloca (len);
 397
 398   store_signed_integer (buf, len, byte_order, value);
 399   write_memory (addr, buf, len);
 400 }
 401 \f
 402 /* The current default bfd target.  Points to storage allocated for
 403    gnutarget_string.  */
 404 const char *gnutarget;
 405
 406 /* Same thing, except it is "auto" not NULL for the default case.  */
 407 static std::string gnutarget_string;
 408 static void
 409 show_gnutarget_string (struct ui_file *file, int from_tty,
 410                        struct cmd_list_element *c,
 411                        const char *value)
 412 {
 413   gdb_printf (file,
 414               _("The current BFD target is \"%s\".\n"), value);
 415 }
 416
 417 static void
 418 set_gnutarget_command (const char *ignore, int from_tty,
 419                        struct cmd_list_element *c)
 420 {
 421   const char *gend = gnutarget_string.c_str () + gnutarget_string.size ();
 422   gend = remove_trailing_whitespace (gnutarget_string.c_str (), gend);
 423   gnutarget_string
 424     = gnutarget_string.substr (0, gend - gnutarget_string.data ());
 425
 426   if (gnutarget_string == "auto")
 427     gnutarget = NULL;
 428   else
 429     gnutarget = gnutarget_string.c_str ();
 430 }
 431
 432 /* A completion function for "set gnutarget".  */
 433
 434 static void
 435 complete_set_gnutarget (struct cmd_list_element *cmd,
 436                         completion_tracker &tracker,
 437                         const char *text, const char *word)
 438 {
 439   static const char **bfd_targets;
 440
 441   if (bfd_targets == NULL)
 442     {
 443       int last;
 444
 445       bfd_targets = bfd_target_list ();
 446       for (last = 0; bfd_targets[last] != NULL; ++last)
 447         ;
 448
 449       bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2);
 450       bfd_targets[last] = "auto";
 451       bfd_targets[last + 1] = NULL;
 452     }
 453
 454   complete_on_enum (tracker, bfd_targets, text, word);
 455 }
 456
 457 /* Set the gnutarget.  */
 458 void
 459 set_gnutarget (const char *newtarget)
 460 {
 461   gnutarget_string = newtarget;
 462   set_gnutarget_command (NULL, 0, NULL);
 463 }
 464
 465 void _initialize_core ();
 466 void
 467 _initialize_core ()
 468 {
 469   cmd_list_element *core_file_cmd
 470     = add_cmd ("core-file", class_files, core_file_command, _("\
 471 Use FILE as core dump for examining memory and registers.\n\
 472 Usage: core-file FILE\n\
 473 No arg means have no core file.  This command has been superseded by the\n\
 474 `target core' and `detach' commands."), &cmdlist);
 475   set_cmd_completer (core_file_cmd, filename_completer);
 476
 477
 478   set_show_commands set_show_gnutarget
 479     = add_setshow_string_noescape_cmd ("gnutarget", class_files,
 480                                        &gnutarget_string, _("\
 481 Set the current BFD target."), _("\
 482 Show the current BFD target."), _("\
 483 Use `set gnutarget auto' to specify automatic detection."),
 484                                        set_gnutarget_command,
 485                                        show_gnutarget_string,
 486                                        &setlist, &showlist);
 487   set_cmd_completer (set_show_gnutarget.set, complete_set_gnutarget);
 488
 489   add_alias_cmd ("g", set_show_gnutarget.set, class_files, 1, &setlist);
 490
 491   if (getenv ("GNUTARGET"))
 492     set_gnutarget (getenv ("GNUTARGET"));
 493   else
 494     set_gnutarget ("auto");
 495 }