gdb/corefile.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2
   3    Copyright (C) 1986-2013 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 "gdb_string.h"
  22 #include <errno.h>
  23 #include <signal.h>
  24 #include <fcntl.h>
  25 #include "inferior.h"
  26 #include "symtab.h"
  27 #include "command.h"
  28 #include "gdbcmd.h"
  29 #include "bfd.h"
  30 #include "target.h"
  31 #include "gdbcore.h"
  32 #include "dis-asm.h"
  33 #include "gdb_stat.h"
  34 #include "completer.h"
  35 #include "exceptions.h"
  36 #include "observer.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
  56                                                    hooks.  */
  57 static int exec_file_hook_count = 0;            /* Size of array.  */
  58
  59 /* Binary file diddling handle for the core file.  */
  60
  61 bfd *core_bfd = NULL;
  62
  63 /* corelow.c target.  It is never NULL after GDB initialization.  */
  64
  65 struct target_ops *core_target;
  66 \f
  67
  68 /* Backward compatability with old way of specifying core files.  */
  69
  70 void
  71 core_file_command (char *filename, int from_tty)
  72 {
  73   dont_repeat ();               /* Either way, seems bogus.  */
  74
  75   gdb_assert (core_target != NULL);
  76
  77   if (!filename)
  78     (core_target->to_detach) (core_target, filename, from_tty);
  79   else
  80     (core_target->to_open) (filename, from_tty);
  81 }
  82 \f
  83
  84 /* If there are two or more functions that wish to hook into
  85    exec_file_command, this function will call all of the hook
  86    functions.  */
  87
  88 static void
  89 call_extra_exec_file_hooks (char *filename)
  90 {
  91   int i;
  92
  93   for (i = 0; i < exec_file_hook_count; i++)
  94     (*exec_file_extra_hooks[i]) (filename);
  95 }
  96
  97 /* Call this to specify the hook for exec_file_command to call back.
  98    This is called from the x-window display code.  */
  99
 100 void
 101 specify_exec_file_hook (void (*hook) (char *))
 102 {
 103   hook_type *new_array;
 104
 105   if (deprecated_exec_file_display_hook != NULL)
 106     {
 107       /* There's already a hook installed.  Arrange to have both it
 108          and the subsequent hooks called.  */
 109       if (exec_file_hook_count == 0)
 110         {
 111           /* If this is the first extra hook, initialize the hook
 112              array.  */
 113           exec_file_extra_hooks = (hook_type *)
 114             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 = (hook_type *)
 125         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 void
 135 reopen_exec_file (void)
 136 {
 137   char *filename;
 138   int res;
 139   struct stat st;
 140   struct cleanup *cleanups;
 141
 142   /* Don't do anything if there isn't an exec file.  */
 143   if (exec_bfd == NULL)
 144     return;
 145
 146   /* If the timestamp of the exec file has changed, reopen it.  */
 147   filename = xstrdup (bfd_get_filename (exec_bfd));
 148   cleanups = make_cleanup (xfree, filename);
 149   res = stat (filename, &st);
 150
 151   if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
 152     exec_file_attach (filename, 0);
 153   else
 154     /* If we accessed the file since last opening it, close it now;
 155        this stops GDB from holding the executable open after it
 156        exits.  */
 157     bfd_cache_close_all ();
 158
 159   do_cleanups (cleanups);
 160 }
 161 \f
 162 /* If we have both a core file and an exec file,
 163    print a warning if they don't go together.  */
 164
 165 void
 166 validate_files (void)
 167 {
 168   if (exec_bfd && core_bfd)
 169     {
 170       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 171         warning (_("core file may not match specified executable file."));
 172       else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
 173         warning (_("exec file is newer than core file."));
 174     }
 175 }
 176
 177 /* Return the name of the executable file as a string.
 178    ERR nonzero means get error if there is none specified;
 179    otherwise return 0 in that case.  */
 180
 181 char *
 182 get_exec_file (int err)
 183 {
 184   if (exec_bfd)
 185     return bfd_get_filename (exec_bfd);
 186   if (!err)
 187     return NULL;
 188
 189   error (_("No executable file specified.\n\
 190 Use the \"file\" or \"exec-file\" command."));
 191   return NULL;
 192 }
 193 \f
 194
 195 /* Report a memory error by throwing a MEMORY_ERROR error.  */
 196
 197 void
 198 memory_error (int status, CORE_ADDR memaddr)
 199 {
 200   if (status == EIO)
 201     /* Actually, address between memaddr and memaddr + len was out of
 202        bounds.  */
 203     throw_error (MEMORY_ERROR,
 204                  _("Cannot access memory at address %s"),
 205                  paddress (target_gdbarch (), memaddr));
 206   else
 207     throw_error (MEMORY_ERROR,
 208                  _("Error accessing memory address %s: %s."),
 209                  paddress (target_gdbarch (), memaddr),
 210                  safe_strerror (status));
 211 }
 212
 213 /* Same as target_read_memory, but report an error if can't read.  */
 214
 215 void
 216 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 217 {
 218   int status;
 219
 220   status = target_read_memory (memaddr, myaddr, len);
 221   if (status != 0)
 222     memory_error (status, memaddr);
 223 }
 224
 225 /* Same as target_read_stack, but report an error if can't read.  */
 226
 227 void
 228 read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
 229 {
 230   int status;
 231
 232   status = target_read_stack (memaddr, myaddr, len);
 233   if (status != 0)
 234     memory_error (status, memaddr);
 235 }
 236
 237 /* Argument / return result struct for use with
 238    do_captured_read_memory_integer().  MEMADDR and LEN are filled in
 239    by gdb_read_memory_integer().  RESULT is the contents that were
 240    successfully read from MEMADDR of length LEN.  */
 241
 242 struct captured_read_memory_integer_arguments
 243 {
 244   CORE_ADDR memaddr;
 245   int len;
 246   enum bfd_endian byte_order;
 247   LONGEST result;
 248 };
 249
 250 /* Helper function for gdb_read_memory_integer().  DATA must be a
 251    pointer to a captured_read_memory_integer_arguments struct.
 252    Return 1 if successful.  Note that the catch_errors() interface
 253    will return 0 if an error occurred while reading memory.  This
 254    choice of return code is so that we can distinguish between
 255    success and failure.  */
 256
 257 static int
 258 do_captured_read_memory_integer (void *data)
 259 {
 260   struct captured_read_memory_integer_arguments *args
 261     = (struct captured_read_memory_integer_arguments*) data;
 262   CORE_ADDR memaddr = args->memaddr;
 263   int len = args->len;
 264   enum bfd_endian byte_order = args->byte_order;
 265
 266   args->result = read_memory_integer (memaddr, len, byte_order);
 267
 268   return 1;
 269 }
 270
 271 /* Read memory at MEMADDR of length LEN and put the contents in
 272    RETURN_VALUE.  Return 0 if MEMADDR couldn't be read and non-zero
 273    if successful.  */
 274
 275 int
 276 safe_read_memory_integer (CORE_ADDR memaddr, int len,
 277                           enum bfd_endian byte_order,
 278                           LONGEST *return_value)
 279 {
 280   int status;
 281   struct captured_read_memory_integer_arguments args;
 282
 283   args.memaddr = memaddr;
 284   args.len = len;
 285   args.byte_order = byte_order;
 286
 287   status = catch_errors (do_captured_read_memory_integer, &args,
 288                          "", RETURN_MASK_ALL);
 289   if (status)
 290     *return_value = args.result;
 291
 292   return status;
 293 }
 294
 295 LONGEST
 296 read_memory_integer (CORE_ADDR memaddr, int len,
 297                      enum bfd_endian byte_order)
 298 {
 299   gdb_byte buf[sizeof (LONGEST)];
 300
 301   read_memory (memaddr, buf, len);
 302   return extract_signed_integer (buf, len, byte_order);
 303 }
 304
 305 ULONGEST
 306 read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
 307                               enum bfd_endian byte_order)
 308 {
 309   gdb_byte buf[sizeof (ULONGEST)];
 310
 311   read_memory (memaddr, buf, len);
 312   return extract_unsigned_integer (buf, len, byte_order);
 313 }
 314
 315 void
 316 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 317 {
 318   char *cp;
 319   int i;
 320   int cnt;
 321
 322   cp = buffer;
 323   while (1)
 324     {
 325       if (cp - buffer >= max_len)
 326         {
 327           buffer[max_len - 1] = '\0';
 328           break;
 329         }
 330       cnt = max_len - (cp - buffer);
 331       if (cnt > 8)
 332         cnt = 8;
 333       read_memory (memaddr + (int) (cp - buffer), cp, cnt);
 334       for (i = 0; i < cnt && *cp; i++, cp++)
 335         ;                       /* null body */
 336
 337       if (i < cnt && !*cp)
 338         break;
 339     }
 340 }
 341
 342 CORE_ADDR
 343 read_memory_typed_address (CORE_ADDR addr, struct type *type)
 344 {
 345   gdb_byte *buf = alloca (TYPE_LENGTH (type));
 346
 347   read_memory (addr, buf, TYPE_LENGTH (type));
 348   return extract_typed_address (buf, type);
 349 }
 350
 351 /* Same as target_write_memory, but report an error if can't
 352    write.  */
 353 void
 354 write_memory (CORE_ADDR memaddr,
 355               const bfd_byte *myaddr, ssize_t len)
 356 {
 357   int status;
 358
 359   status = target_write_memory (memaddr, myaddr, len);
 360   if (status != 0)
 361     memory_error (status, memaddr);
 362 }
 363
 364 /* Same as write_memory, but notify 'memory_changed' observers.  */
 365
 366 void
 367 write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
 368                                 ssize_t len)
 369 {
 370   write_memory (memaddr, myaddr, len);
 371   observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
 372 }
 373
 374 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
 375    integer.  */
 376 void
 377 write_memory_unsigned_integer (CORE_ADDR addr, int len,
 378                                enum bfd_endian byte_order,
 379                                ULONGEST value)
 380 {
 381   gdb_byte *buf = alloca (len);
 382
 383   store_unsigned_integer (buf, len, byte_order, value);
 384   write_memory (addr, buf, len);
 385 }
 386
 387 /* Store VALUE at ADDR in the inferior as a LEN-byte signed
 388    integer.  */
 389 void
 390 write_memory_signed_integer (CORE_ADDR addr, int len,
 391                              enum bfd_endian byte_order,
 392                              LONGEST value)
 393 {
 394   gdb_byte *buf = alloca (len);
 395
 396   store_signed_integer (buf, len, byte_order, value);
 397   write_memory (addr, buf, len);
 398 }
 399 \f
 400 /* The current default bfd target.  Points to storage allocated for
 401    gnutarget_string.  */
 402 char *gnutarget;
 403
 404 /* Same thing, except it is "auto" not NULL for the default case.  */
 405 static char *gnutarget_string;
 406 static void
 407 show_gnutarget_string (struct ui_file *file, int from_tty,
 408                        struct cmd_list_element *c,
 409                        const char *value)
 410 {
 411   fprintf_filtered (file,
 412                     _("The current BFD target is \"%s\".\n"), value);
 413 }
 414
 415 static void set_gnutarget_command (char *, int,
 416                                    struct cmd_list_element *);
 417
 418 static void
 419 set_gnutarget_command (char *ignore, int from_tty,
 420                        struct cmd_list_element *c)
 421 {
 422   if (strcmp (gnutarget_string, "auto") == 0)
 423     gnutarget = NULL;
 424   else
 425     gnutarget = gnutarget_string;
 426 }
 427
 428 /* Set the gnutarget.  */
 429 void
 430 set_gnutarget (char *newtarget)
 431 {
 432   if (gnutarget_string != NULL)
 433     xfree (gnutarget_string);
 434   gnutarget_string = xstrdup (newtarget);
 435   set_gnutarget_command (NULL, 0, NULL);
 436 }
 437
 438 void
 439 _initialize_core (void)
 440 {
 441   struct cmd_list_element *c;
 442
 443   c = add_cmd ("core-file", class_files, core_file_command, _("\
 444 Use FILE as core dump for examining memory and registers.\n\
 445 No arg means have no core file.  This command has been superseded by the\n\
 446 `target core' and `detach' commands."), &cmdlist);
 447   set_cmd_completer (c, filename_completer);
 448
 449
 450   add_setshow_string_noescape_cmd ("gnutarget", class_files,
 451                                    &gnutarget_string, _("\
 452 Set the current BFD target."), _("\
 453 Show the current BFD target."), _("\
 454 Use `set gnutarget auto' to specify automatic detection."),
 455                                    set_gnutarget_command,
 456                                    show_gnutarget_string,
 457                                    &setlist, &showlist);
 458   add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
 459
 460   if (getenv ("GNUTARGET"))
 461     set_gnutarget (getenv ("GNUTARGET"));
 462   else
 463     set_gnutarget ("auto");
 464 }