gdb/corefile.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Core dump and executable file functions above target vector, for GDB.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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 "observer.h"
  34. #include "cli/cli-utils.h"

  36. /* Local function declarations.  */

  38. extern void _initialize_core (void);

  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.  */

  49. ‌typedef void (*hook_type) (const char *);

  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.  */

  56. /* Binary file diddling handle for the core file.  */

  58. ‌bfd *core_bfd = NULL;

  60. /* corelow.c target.  It is never NULL after GDB initialization.  */

  62. ‌struct target_ops *core_target;


  65. /* Backward compatability with old way of specifying core files.  */

  67. void
  68. ‌core_file_command (char *filename, int from_tty)
  69. {
  70.   dont_repeat ();                /* Either way, seems bogus.  */

  72.   gdb_assert (core_target != NULL);

  74.   if (!filename)
  75.     (core_target->to_detach) (core_target, filename, from_tty);
  76.   else
  77.     (core_target->to_open) (filename, from_tty);
  78. }


  81. /* If there are two or more functions that wish to hook into
  82.    exec_file_command, this function will call all of the hook
  83.    functions.  */

  85. static void
  86. ‌call_extra_exec_file_hooks (const char *filename)
  87. {
  88.   int i;

  90.   for (i = 0; i < exec_file_hook_count; i++)
  91.     (*exec_file_extra_hooks[i]) (filename);
  92. }

  94. /* Call this to specify the hook for exec_file_command to call back.
  95.    This is called from the x-window display code.  */

  97. void
  98. ‌specify_exec_file_hook (void (*hook) (const char *))
  99. {
  100.   hook_type *new_array;

  102.   if (deprecated_exec_file_display_hook != NULL)
  103.     {
  104.       /* There's already a hook installed.  Arrange to have both it
  105.          and the subsequent hooks called.  */
  106.       if (exec_file_hook_count == 0)
  107.         {
  108.           /* If this is the first extra hook, initialize the hook
  109.              array.  */
  110.           exec_file_extra_hooks = (hook_type *)
  111.             xmalloc (sizeof (hook_type));
  112.           exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
  113.           deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
  114.           exec_file_hook_count = 1;
  115.         }

  117.       /* Grow the hook array by one and add the new hook to the end.
  118.          Yes, it's inefficient to grow it by one each time but since
  119.          this is hardly ever called it's not a big deal.  */
  120.       exec_file_hook_count++;
  121.       new_array = (hook_type *)
  122.         xrealloc (exec_file_extra_hooks,
  123.                   exec_file_hook_count * sizeof (hook_type));
  124.       exec_file_extra_hooks = new_array;
  125.       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
  126.     }
  127.   else
  128.     deprecated_exec_file_display_hook = hook;
  129. }

  131. void
  132. ‌reopen_exec_file (void)
  133. {
  134.   char *filename;
  135.   int res;
  136.   struct stat st;
  137.   struct cleanup *cleanups;

  139.   /* Don't do anything if there isn't an exec file.  */
  140.   if (exec_bfd == NULL)
  141.     return;

  143.   /* If the timestamp of the exec file has changed, reopen it.  */
  144.   filename = xstrdup (bfd_get_filename (exec_bfd));
  145.   cleanups = make_cleanup (xfree, filename);
  146.   res = stat (filename, &st);

  148.   if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
  149.     exec_file_attach (filename, 0);
  150.   else
  151.     /* If we accessed the file since last opening it, close it now;
  152.        this stops GDB from holding the executable open after it
  153.        exits.  */
  154.     bfd_cache_close_all ();

  156.   do_cleanups (cleanups);
  157. }

  159. /* If we have both a core file and an exec file,
  160.    print a warning if they don't go together.  */

  162. void
  163. ‌validate_files (void)
  164. {
  165.   if (exec_bfd && core_bfd)
  166.     {
  167.       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
  168.         warning (_("core file may not match specified executable file."));
  169.       else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
  170.         warning (_("exec file is newer than core file."));
  171.     }
  172. }

  174. /* Return the name of the executable file as a string.
  175.    ERR nonzero means get error if there is none specified;
  176.    otherwise return 0 in that case.  */

  178. char *
  179. ‌get_exec_file (int err)
  180. {
  181.   if (exec_filename)
  182.     return exec_filename;
  183.   if (!err)
  184.     return NULL;

  186.   error (_("No executable file specified.\n\
  187. Use the \"file\" or \"exec-file\" command."));
  188.   return NULL;
  189. }


  192. char *
  193. ‌memory_error_message (enum target_xfer_status err,
  194.                       struct gdbarch *gdbarch, CORE_ADDR memaddr)
  195. {
  196.   switch (err)
  197.     {
  198.     case TARGET_XFER_E_IO:
  199.       /* Actually, address between memaddr and memaddr + len was out of
  200.          bounds.  */
  201.       return xstrprintf (_("Cannot access memory at address %s"),
  202.                          paddress (gdbarch, memaddr));
  203.     case TARGET_XFER_UNAVAILABLE:
  204.       return xstrprintf (_("Memory at address %s unavailable."),
  205.                          paddress (gdbarch, memaddr));
  206.     default:
  207.       internal_error (__FILE__, __LINE__,
  208.                       "unhandled target_xfer_status: %s (%s)",
  209.                       target_xfer_status_to_string (err),
  210.                       plongest (err));
  211.     }
  212. }

  214. /* Report a memory error by throwing a suitable exception.  */

  216. void
  217. ‌memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
  218. {
  219.   char *str;
  220.   enum errors exception = GDB_NO_ERROR;

  222.   /* Build error string.  */
  223.   str = memory_error_message (err, target_gdbarch (), memaddr);
  224.   make_cleanup (xfree, str);

  226.   /* Choose the right error to throw.  */
  227.   switch (err)
  228.     {
  229.     case TARGET_XFER_E_IO:
  230.       exception = MEMORY_ERROR;
  231.       break;
  232.     case TARGET_XFER_UNAVAILABLE:
  233.       exception = NOT_AVAILABLE_ERROR;
  234.       break;
  235.     }

  237.   /* Throw it.  */
  238.   throw_error (exception, ("%s"), str);
  239. }

  241. /* Same as target_read_memory, but report an error if can't read.  */

  243. void
  244. ‌read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
  245. {
  246.   ULONGEST xfered = 0;

  248.   while (xfered < len)
  249.     {
  250.       enum target_xfer_status status;
  251.       ULONGEST xfered_len;

  253.       status = target_xfer_partial (current_target.beneath,
  254.                                     TARGET_OBJECT_MEMORY, NULL,
  255.                                     myaddr + xfered, NULL,
  256.                                     memaddr + xfered, len - xfered,
  257.                                     &xfered_len);

  259.       if (status != TARGET_XFER_OK)
  260.         memory_error (status == TARGET_XFER_EOF ? TARGET_XFER_E_IO : status,
  261.                       memaddr + xfered);

  263.       xfered += xfered_len;
  264.       QUIT;
  265.     }
  266. }

  268. /* Same as target_read_stack, but report an error if can't read.  */

  270. void
  271. ‌read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
  272. {
  273.   int status;

  275.   status = target_read_stack (memaddr, myaddr, len);
  276.   if (status != 0)
  277.     memory_error (status, memaddr);
  278. }

  280. /* Same as target_read_code, but report an error if can't read.  */

  282. void
  283. ‌read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
  284. {
  285.   int status;

  287.   status = target_read_code (memaddr, myaddr, len);
  288.   if (status != 0)
  289.     memory_error (status, memaddr);
  290. }

  292. /* Read memory at MEMADDR of length LEN and put the contents in
  293.    RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
  294.    if successful.  */

  296. int
  297. ‌safe_read_memory_integer (CORE_ADDR memaddr, int len,
  298.                           enum bfd_endian byte_order,
  299.                           LONGEST *return_value)
  300. {
  301.   gdb_byte buf[sizeof (LONGEST)];

  303.   if (target_read_memory (memaddr, buf, len))
  304.     return 0;

  306.   *return_value = extract_signed_integer (buf, len, byte_order);
  307.   return 1;
  308. }

  310. LONGEST
  311. ‌read_memory_integer (CORE_ADDR memaddr, int len,
  312.                      enum bfd_endian byte_order)
  313. {
  314.   gdb_byte buf[sizeof (LONGEST)];

  316.   read_memory (memaddr, buf, len);
  317.   return extract_signed_integer (buf, len, byte_order);
  318. }

  320. ULONGEST
  321. ‌read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
  322.                               enum bfd_endian byte_order)
  323. {
  324.   gdb_byte buf[sizeof (ULONGEST)];

  326.   read_memory (memaddr, buf, len);
  327.   return extract_unsigned_integer (buf, len, byte_order);
  328. }

  330. LONGEST
  331. ‌read_code_integer (CORE_ADDR memaddr, int len,
  332.                    enum bfd_endian byte_order)
  333. {
  334.   gdb_byte buf[sizeof (LONGEST)];

  336.   read_code (memaddr, buf, len);
  337.   return extract_signed_integer (buf, len, byte_order);
  338. }

  340. ULONGEST
  341. ‌read_code_unsigned_integer (CORE_ADDR memaddr, int len,
  342.                             enum bfd_endian byte_order)
  343. {
  344.   gdb_byte buf[sizeof (ULONGEST)];

  346.   read_code (memaddr, buf, len);
  347.   return extract_unsigned_integer (buf, len, byte_order);
  348. }

  350. void
  351. ‌read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
  352. {
  353.   char *cp;
  354.   int i;
  355.   int cnt;

  357.   cp = buffer;
  358.   while (1)
  359.     {
  360.       if (cp - buffer >= max_len)
  361.         {
  362.           buffer[max_len - 1] = '\0';
  363.           break;
  364.         }
  365.       cnt = max_len - (cp - buffer);
  366.       if (cnt > 8)
  367.         cnt = 8;
  368.       read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
  369.       for (i = 0; i < cnt && *cp; i++, cp++)
  370.         ;                        /* null body */

  372.       if (i < cnt && !*cp)
  373.         break;
  374.     }
  375. }

  377. CORE_ADDR
  378. ‌read_memory_typed_address (CORE_ADDR addr, struct type *type)
  379. {
  380.   gdb_byte *buf = alloca (TYPE_LENGTH (type));

  382.   read_memory (addr, buf, TYPE_LENGTH (type));
  383.   return extract_typed_address (buf, type);
  384. }

  386. /* Same as target_write_memory, but report an error if can't
  387.    write.  */
  388. void
  389. ‌write_memory (CORE_ADDR memaddr,
  390.               const bfd_byte *myaddr, ssize_t len)
  391. {
  392.   int status;

  394.   status = target_write_memory (memaddr, myaddr, len);
  395.   if (status != 0)
  396.     memory_error (status, memaddr);
  397. }

  399. /* Same as write_memory, but notify 'memory_changed' observers.  */

  401. void
  402. ‌write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
  403.                                 ssize_t len)
  404. {
  405.   write_memory (memaddr, myaddr, len);
  406.   observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
  407. }

  409. /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
  410.    integer.  */
  411. void
  412. ‌write_memory_unsigned_integer (CORE_ADDR addr, int len,
  413.                                enum bfd_endian byte_order,
  414.                                ULONGEST value)
  415. {
  416.   gdb_byte *buf = alloca (len);

  418.   store_unsigned_integer (buf, len, byte_order, value);
  419.   write_memory (addr, buf, len);
  420. }

  422. /* Store VALUE at ADDR in the inferior as a LEN-byte signed
  423.    integer.  */
  424. void
  425. ‌write_memory_signed_integer (CORE_ADDR addr, int len,
  426.                              enum bfd_endian byte_order,
  427.                              LONGEST value)
  428. {
  429.   gdb_byte *buf = alloca (len);

  431.   store_signed_integer (buf, len, byte_order, value);
  432.   write_memory (addr, buf, len);
  433. }

  435. /* The current default bfd target.  Points to storage allocated for
  436.    gnutarget_string.  */
  437. ‌char *gnutarget;

  439. /* Same thing, except it is "auto" not NULL for the default case.  */
  440. ‌static char *gnutarget_string;
  441. static void
  442. ‌show_gnutarget_string (struct ui_file *file, int from_tty,
  443.                        struct cmd_list_element *c,
  444.                        const char *value)
  445. {
  446.   fprintf_filtered (file,
  447.                     _("The current BFD target is \"%s\".\n"), value);
  448. }

  450. static void set_gnutarget_command (char *, int,
  451.                                    struct cmd_list_element *);

  453. static void
  454. ‌set_gnutarget_command (char *ignore, int from_tty,
  455.                        struct cmd_list_element *c)
  456. {
  457.   char *gend = gnutarget_string + strlen (gnutarget_string);

  459.   gend = remove_trailing_whitespace (gnutarget_string, gend);
  460.   *gend = '\0';

  462.   if (strcmp (gnutarget_string, "auto") == 0)
  463.     gnutarget = NULL;
  464.   else
  465.     gnutarget = gnutarget_string;
  466. }

  468. /* A completion function for "set gnutarget".  */

  470. ‌static VEC (char_ptr) *
  471. complete_set_gnutarget (struct cmd_list_element *cmd,
  472.                         const char *text, const char *word)
  473. {
  474.   static const char **bfd_targets;

  476.   if (bfd_targets == NULL)
  477.     {
  478.       int last;

  480.       bfd_targets = bfd_target_list ();
  481.       for (last = 0; bfd_targets[last] != NULL; ++last)
  482.         ;

  484.       bfd_targets = xrealloc (bfd_targets, (last + 2) * sizeof (const char **));
  485.       bfd_targets[last] = "auto";
  486.       bfd_targets[last + 1] = NULL;
  487.     }

  489.   return complete_on_enum (bfd_targets, text, word);
  490. }

  492. /* Set the gnutarget.  */
  493. void
  494. ‌set_gnutarget (char *newtarget)
  495. {
  496.   if (gnutarget_string != NULL)
  497.     xfree (gnutarget_string);
  498.   gnutarget_string = xstrdup (newtarget);
  499.   set_gnutarget_command (NULL, 0, NULL);
  500. }

  502. void
  503. ‌_initialize_core (void)
  504. {
  505.   struct cmd_list_element *c;

  507.   c = add_cmd ("core-file", class_files, core_file_command, _("\
  508. Use FILE as core dump for examining memory and registers.\n\
  509. No arg means have no core file.  This command has been superseded by the\n\
  510. `target core' and `detach' commands."), &cmdlist);
  511.   set_cmd_completer (c, filename_completer);


  514.   c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
  515.                                        &gnutarget_string, _("\
  516. Set the current BFD target."), _("\
  517. Show the current BFD target."), _("\
  518. Use `set gnutarget auto' to specify automatic detection."),
  519.                                        set_gnutarget_command,
  520.                                        show_gnutarget_string,
  521.                                        &setlist, &showlist);
  522.   set_cmd_completer (c, complete_set_gnutarget);

  524.   add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);

  526.   if (getenv ("GNUTARGET"))
  527.     set_gnutarget (getenv ("GNUTARGET"));
  528.   else
  529.     set_gnutarget ("auto");
  530. }