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