gdb/corefile.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2003, 2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "gdb_string.h"
  23 #include <errno.h>
  24 #include <signal.h>
  25 #include <fcntl.h>
  26 #include "inferior.h"
  27 #include "symtab.h"
  28 #include "command.h"
  29 #include "gdbcmd.h"
  30 #include "bfd.h"
  31 #include "target.h"
  32 #include "gdbcore.h"
  33 #include "dis-asm.h"
  34 #include "gdb_stat.h"
  35 #include "completer.h"
  36 #include "exceptions.h"
  37
  38 /* Local function declarations.  */
  39
  40 extern void _initialize_core (void);
  41 static void call_extra_exec_file_hooks (char *filename);
  42
  43 /* You can have any number of hooks for `exec_file_command' command to
  44    call.  If there's only one hook, it is set in exec_file_display
  45    hook.  If there are two or more hooks, they are set in
  46    exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
  47    set to a function that calls all of them.  This extra complexity is
  48    needed to preserve compatibility with old code that assumed that
  49    only one hook could be set, and which called
  50    deprecated_exec_file_display_hook directly.  */
  51
  52 typedef void (*hook_type) (char *);
  53
  54 hook_type deprecated_exec_file_display_hook;    /* the original hook */
  55 static hook_type *exec_file_extra_hooks;        /* array of additional hooks */
  56 static int exec_file_hook_count = 0;    /* size of array */
  57
  58 /* Binary file diddling handle for the core file.  */
  59
  60 bfd *core_bfd = NULL;
  61 \f
  62
  63 /* Backward compatability with old way of specifying core files.  */
  64
  65 void
  66 core_file_command (char *filename, int from_tty)
  67 {
  68   struct target_ops *t;
  69
  70   dont_repeat ();               /* Either way, seems bogus. */
  71
  72   t = find_core_target ();
  73   if (t == NULL)
  74     error (_("GDB can't read core files on this machine."));
  75
  76   if (!filename)
  77     (t->to_detach) (filename, from_tty);
  78   else
  79     (t->to_open) (filename, from_tty);
  80 }
  81 \f
  82
  83 /* If there are two or more functions that wish to hook into
  84    exec_file_command, this function will call all of the hook
  85    functions.  */
  86
  87 static void
  88 call_extra_exec_file_hooks (char *filename)
  89 {
  90   int i;
  91
  92   for (i = 0; i < exec_file_hook_count; i++)
  93     (*exec_file_extra_hooks[i]) (filename);
  94 }
  95
  96 /* Call this to specify the hook for exec_file_command to call back.
  97    This is called from the x-window display code.  */
  98
  99 void
 100 specify_exec_file_hook (void (*hook) (char *))
 101 {
 102   hook_type *new_array;
 103
 104   if (deprecated_exec_file_display_hook != NULL)
 105     {
 106       /* There's already a hook installed.  Arrange to have both it
 107        * and the subsequent hooks called. */
 108       if (exec_file_hook_count == 0)
 109         {
 110           /* If this is the first extra hook, initialize the hook array.  */
 111           exec_file_extra_hooks = (hook_type *) 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         }
 116
 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 =
 122         (hook_type *) 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 }
 130
 131 /* The exec file must be closed before running an inferior.
 132    If it is needed again after the inferior dies, it must
 133    be reopened.  */
 134
 135 void
 136 close_exec_file (void)
 137 {
 138 #if 0                           /* FIXME */
 139   if (exec_bfd)
 140     bfd_tempclose (exec_bfd);
 141 #endif
 142 }
 143
 144 void
 145 reopen_exec_file (void)
 146 {
 147 #if 0                           /* FIXME */
 148   if (exec_bfd)
 149     bfd_reopen (exec_bfd);
 150 #else
 151   char *filename;
 152   int res;
 153   struct stat st;
 154   long mtime;
 155
 156   /* Don't do anything if there isn't an exec file. */
 157   if (exec_bfd == NULL)
 158     return;
 159
 160   /* If the timestamp of the exec file has changed, reopen it. */
 161   filename = xstrdup (bfd_get_filename (exec_bfd));
 162   make_cleanup (xfree, filename);
 163   res = stat (filename, &st);
 164
 165   if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
 166     exec_file_attach (filename, 0);
 167 #endif
 168 }
 169 \f
 170 /* If we have both a core file and an exec file,
 171    print a warning if they don't go together.  */
 172
 173 void
 174 validate_files (void)
 175 {
 176   if (exec_bfd && core_bfd)
 177     {
 178       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 179         warning (_("core file may not match specified executable file."));
 180       else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
 181         warning (_("exec file is newer than core file."));
 182     }
 183 }
 184
 185 /* Return the name of the executable file as a string.
 186    ERR nonzero means get error if there is none specified;
 187    otherwise return 0 in that case.  */
 188
 189 char *
 190 get_exec_file (int err)
 191 {
 192   if (exec_bfd)
 193     return bfd_get_filename (exec_bfd);
 194   if (!err)
 195     return NULL;
 196
 197   error (_("No executable file specified.\n\
 198 Use the \"file\" or \"exec-file\" command."));
 199   return NULL;
 200 }
 201 \f
 202
 203 /* Report a memory error with error().  */
 204
 205 void
 206 memory_error (int status, CORE_ADDR memaddr)
 207 {
 208   struct ui_file *tmp_stream = mem_fileopen ();
 209   make_cleanup_ui_file_delete (tmp_stream);
 210
 211   if (status == EIO)
 212     {
 213       /* Actually, address between memaddr and memaddr + len
 214          was out of bounds. */
 215       fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
 216       fputs_filtered (paddress (memaddr), tmp_stream);
 217     }
 218   else
 219     {
 220       fprintf_filtered (tmp_stream, "Error accessing memory address ");
 221       fputs_filtered (paddress (memaddr), tmp_stream);
 222       fprintf_filtered (tmp_stream, ": %s.",
 223                        safe_strerror (status));
 224     }
 225
 226   error_stream (tmp_stream);
 227 }
 228
 229 /* Same as target_read_memory, but report an error if can't read.  */
 230 void
 231 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 232 {
 233   int status;
 234   status = target_read_memory (memaddr, myaddr, len);
 235   if (status != 0)
 236     memory_error (status, memaddr);
 237 }
 238
 239 /* Argument / return result struct for use with
 240    do_captured_read_memory_integer().  MEMADDR and LEN are filled in
 241    by gdb_read_memory_integer().  RESULT is the contents that were
 242    successfully read from MEMADDR of length LEN.  */
 243
 244 struct captured_read_memory_integer_arguments
 245 {
 246   CORE_ADDR memaddr;
 247   int len;
 248   LONGEST result;
 249 };
 250
 251 /* Helper function for gdb_read_memory_integer().  DATA must be a
 252    pointer to a captured_read_memory_integer_arguments struct.
 253    Return 1 if successful.  Note that the catch_errors() interface
 254    will return 0 if an error occurred while reading memory.  This
 255    choice of return code is so that we can distinguish between
 256    success and failure.  */
 257
 258 static int
 259 do_captured_read_memory_integer (void *data)
 260 {
 261   struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
 262   CORE_ADDR memaddr = args->memaddr;
 263   int len = args->len;
 264
 265   args->result = read_memory_integer (memaddr, len);
 266
 267   return 1;
 268 }
 269
 270 /* Read memory at MEMADDR of length LEN and put the contents in
 271    RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
 272    if successful.  */
 273
 274 int
 275 safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
 276 {
 277   int status;
 278   struct captured_read_memory_integer_arguments args;
 279   args.memaddr = memaddr;
 280   args.len = len;
 281
 282   status = catch_errors (do_captured_read_memory_integer, &args,
 283                         "", RETURN_MASK_ALL);
 284   if (status)
 285     *return_value = args.result;
 286
 287   return status;
 288 }
 289
 290 LONGEST
 291 read_memory_integer (CORE_ADDR memaddr, int len)
 292 {
 293   gdb_byte buf[sizeof (LONGEST)];
 294
 295   read_memory (memaddr, buf, len);
 296   return extract_signed_integer (buf, len);
 297 }
 298
 299 ULONGEST
 300 read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
 301 {
 302   gdb_byte buf[sizeof (ULONGEST)];
 303
 304   read_memory (memaddr, buf, len);
 305   return extract_unsigned_integer (buf, len);
 306 }
 307
 308 void
 309 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 310 {
 311   char *cp;
 312   int i;
 313   int cnt;
 314
 315   cp = buffer;
 316   while (1)
 317     {
 318       if (cp - buffer >= max_len)
 319         {
 320           buffer[max_len - 1] = '\0';
 321           break;
 322         }
 323       cnt = max_len - (cp - buffer);
 324       if (cnt > 8)
 325         cnt = 8;
 326       read_memory (memaddr + (int) (cp - buffer), cp, cnt);
 327       for (i = 0; i < cnt && *cp; i++, cp++)
 328         ;                       /* null body */
 329
 330       if (i < cnt && !*cp)
 331         break;
 332     }
 333 }
 334
 335 CORE_ADDR
 336 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 337 {
 338   gdb_byte *buf = alloca (TYPE_LENGTH (type));
 339   read_memory (addr, buf, TYPE_LENGTH (type));
 340   return extract_typed_address (buf, type);
 341 }
 342
 343 /* Same as target_write_memory, but report an error if can't write.  */
 344 void
 345 write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
 346 {
 347   int status;
 348   gdb_byte *bytes = alloca (len);
 349
 350   memcpy (bytes, myaddr, len);
 351   status = target_write_memory (memaddr, bytes, len);
 352   if (status != 0)
 353     memory_error (status, memaddr);
 354 }
 355
 356 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
 357 void
 358 write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
 359 {
 360   gdb_byte *buf = alloca (len);
 361   store_unsigned_integer (buf, len, value);
 362   write_memory (addr, buf, len);
 363 }
 364
 365 /* Store VALUE at ADDR in the inferior as a LEN-byte signed integer.  */
 366 void
 367 write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
 368 {
 369   gdb_byte *buf = alloca (len);
 370   store_signed_integer (buf, len, value);
 371   write_memory (addr, buf, len);
 372 }
 373
 374 \f
 375
 376 #if 0
 377 /* Enable after 4.12.  It is not tested.  */
 378
 379 /* Search code.  Targets can just make this their search function, or
 380    if the protocol has a less general search function, they can call this
 381    in the cases it can't handle.  */
 382 void
 383 generic_search (int len, char *data, char *mask, CORE_ADDR startaddr,
 384                 int increment, CORE_ADDR lorange, CORE_ADDR hirange,
 385                 CORE_ADDR *addr_found, char *data_found)
 386 {
 387   int i;
 388   CORE_ADDR curaddr = startaddr;
 389
 390   while (curaddr >= lorange && curaddr < hirange)
 391     {
 392       read_memory (curaddr, data_found, len);
 393       for (i = 0; i < len; ++i)
 394         if ((data_found[i] & mask[i]) != data[i])
 395           goto try_again;
 396       /* It matches.  */
 397       *addr_found = curaddr;
 398       return;
 399
 400     try_again:
 401       curaddr += increment;
 402     }
 403   *addr_found = (CORE_ADDR) 0;
 404   return;
 405 }
 406 #endif /* 0 */
 407 \f
 408 /* The current default bfd target.  Points to storage allocated for
 409    gnutarget_string.  */
 410 char *gnutarget;
 411
 412 /* Same thing, except it is "auto" not NULL for the default case.  */
 413 static char *gnutarget_string;
 414 static void
 415 show_gnutarget_string (struct ui_file *file, int from_tty,
 416                        struct cmd_list_element *c, const char *value)
 417 {
 418   fprintf_filtered (file, _("The current BFD target is \"%s\".\n"), value);
 419 }
 420
 421 static void set_gnutarget_command (char *, int, struct cmd_list_element *);
 422
 423 static void
 424 set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
 425 {
 426   if (strcmp (gnutarget_string, "auto") == 0)
 427     gnutarget = NULL;
 428   else
 429     gnutarget = gnutarget_string;
 430 }
 431
 432 /* Set the gnutarget.  */
 433 void
 434 set_gnutarget (char *newtarget)
 435 {
 436   if (gnutarget_string != NULL)
 437     xfree (gnutarget_string);
 438   gnutarget_string = savestring (newtarget, strlen (newtarget));
 439   set_gnutarget_command (NULL, 0, NULL);
 440 }
 441
 442 void
 443 _initialize_core (void)
 444 {
 445   struct cmd_list_element *c;
 446   c = add_cmd ("core-file", class_files, core_file_command, _("\
 447 Use FILE as core dump for examining memory and registers.\n\
 448 No arg means have no core file.  This command has been superseded by the\n\
 449 `target core' and `detach' commands."), &cmdlist);
 450   set_cmd_completer (c, filename_completer);
 451
 452
 453   add_setshow_string_noescape_cmd ("gnutarget", class_files,
 454                                    &gnutarget_string, _("(\
 455 Set the current BFD target."), _("\
 456 Show the current BFD target."), _("\
 457 Use `set gnutarget auto' to specify automatic detection."),
 458                                    set_gnutarget_command,
 459                                    show_gnutarget_string,
 460                                    &setlist, &showlist);
 461
 462   if (getenv ("GNUTARGET"))
 463     set_gnutarget (getenv ("GNUTARGET"));
 464   else
 465     set_gnutarget ("auto");
 466 }