gdb/corefile.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2    Copyright 1986, 1987, 1989, 1991-1994, 2000
   3    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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include <errno.h>
  25 #include <signal.h>
  26 #include <fcntl.h>
  27 #include "frame.h"              /* required by inferior.h */
  28 #include "inferior.h"
  29 #include "symtab.h"
  30 #include "command.h"
  31 #include "gdbcmd.h"
  32 #include "symfile.h"
  33 #include "bfd.h"
  34 #include "target.h"
  35 #include "gdbcore.h"
  36 #include "dis-asm.h"
  37 #include "language.h"
  38 #include "gdb_stat.h"
  39 #include "symfile.h"
  40 #include "objfiles.h"
  41 #include "completer.h"
  42
  43 /* Local function declarations.  */
  44
  45 extern void _initialize_core (void);
  46 static void call_extra_exec_file_hooks (char *filename);
  47
  48 /* You can have any number of hooks for `exec_file_command' command to call.
  49    If there's only one hook, it is set in exec_file_display hook.
  50    If there are two or more hooks, they are set in exec_file_extra_hooks[],
  51    and exec_file_display_hook is set to a function that calls all of them.
  52    This extra complexity is needed to preserve compatibility with
  53    old code that assumed that only one hook could be set, and which called
  54    exec_file_display_hook directly.  */
  55
  56 typedef void (*hook_type) (char *);
  57
  58 hook_type exec_file_display_hook;       /* the original hook */
  59 static hook_type *exec_file_extra_hooks;        /* array of additional hooks */
  60 static int exec_file_hook_count = 0;    /* size of array */
  61
  62 /* Binary file diddling handle for the core file.  */
  63
  64 bfd *core_bfd = NULL;
  65 \f
  66
  67 /* Backward compatability with old way of specifying core files.  */
  68
  69 void
  70 core_file_command (char *filename, int from_tty)
  71 {
  72   struct target_ops *t;
  73
  74   dont_repeat ();               /* Either way, seems bogus. */
  75
  76   t = find_core_target ();
  77   if (t != NULL)
  78     if (!filename)
  79       (t->to_detach) (filename, from_tty);
  80     else
  81       {
  82         /* Yes, we were given the path of a core file.  Do we already
  83            have a symbol file?  If not, can we determine it from the
  84            core file?  If we can, do so.
  85          */
  86 #ifdef HPUXHPPA
  87         if (symfile_objfile == NULL)
  88           {
  89             char *symfile;
  90             symfile = t->to_core_file_to_sym_file (filename);
  91             if (symfile)
  92               {
  93                 char *symfile_copy = xstrdup (symfile);
  94
  95                 make_cleanup (xfree, symfile_copy);
  96                 symbol_file_add_main (symfile_copy, from_tty);
  97               }
  98             else
  99               warning ("Unknown symbols for '%s'; use the 'symbol-file' command.", filename);
 100           }
 101 #endif
 102         (t->to_open) (filename, from_tty);
 103       }
 104   else
 105     error ("GDB can't read core files on this machine.");
 106 }
 107 \f
 108
 109 /* If there are two or more functions that wish to hook into exec_file_command,
 110  * this function will call all of the hook functions. */
 111
 112 static void
 113 call_extra_exec_file_hooks (char *filename)
 114 {
 115   int i;
 116
 117   for (i = 0; i < exec_file_hook_count; i++)
 118     (*exec_file_extra_hooks[i]) (filename);
 119 }
 120
 121 /* Call this to specify the hook for exec_file_command to call back.
 122    This is called from the x-window display code.  */
 123
 124 void
 125 specify_exec_file_hook (void (*hook) (char *))
 126 {
 127   hook_type *new_array;
 128
 129   if (exec_file_display_hook != NULL)
 130     {
 131       /* There's already a hook installed.  Arrange to have both it
 132        * and the subsequent hooks called. */
 133       if (exec_file_hook_count == 0)
 134         {
 135           /* If this is the first extra hook, initialize the hook array. */
 136           exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type));
 137           exec_file_extra_hooks[0] = exec_file_display_hook;
 138           exec_file_display_hook = call_extra_exec_file_hooks;
 139           exec_file_hook_count = 1;
 140         }
 141
 142       /* Grow the hook array by one and add the new hook to the end.
 143          Yes, it's inefficient to grow it by one each time but since
 144          this is hardly ever called it's not a big deal.  */
 145       exec_file_hook_count++;
 146       new_array =
 147         (hook_type *) xrealloc (exec_file_extra_hooks,
 148                                 exec_file_hook_count * sizeof (hook_type));
 149       exec_file_extra_hooks = new_array;
 150       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
 151     }
 152   else
 153     exec_file_display_hook = hook;
 154 }
 155
 156 /* The exec file must be closed before running an inferior.
 157    If it is needed again after the inferior dies, it must
 158    be reopened.  */
 159
 160 void
 161 close_exec_file (void)
 162 {
 163 #if 0                           /* FIXME */
 164   if (exec_bfd)
 165     bfd_tempclose (exec_bfd);
 166 #endif
 167 }
 168
 169 void
 170 reopen_exec_file (void)
 171 {
 172 #if 0                           /* FIXME */
 173   if (exec_bfd)
 174     bfd_reopen (exec_bfd);
 175 #else
 176   char *filename;
 177   int res;
 178   struct stat st;
 179   long mtime;
 180
 181   /* Don't do anything if the current target isn't exec. */
 182   if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0)
 183     return;
 184
 185   /* If the timestamp of the exec file has changed, reopen it. */
 186   filename = xstrdup (bfd_get_filename (exec_bfd));
 187   make_cleanup (xfree, filename);
 188   mtime = bfd_get_mtime (exec_bfd);
 189   res = stat (filename, &st);
 190
 191   if (mtime && mtime != st.st_mtime)
 192     {
 193       exec_open (filename, 0);
 194     }
 195 #endif
 196 }
 197 \f
 198 /* If we have both a core file and an exec file,
 199    print a warning if they don't go together.  */
 200
 201 void
 202 validate_files (void)
 203 {
 204   if (exec_bfd && core_bfd)
 205     {
 206       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 207         warning ("core file may not match specified executable file.");
 208       else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
 209         warning ("exec file is newer than core file.");
 210     }
 211 }
 212
 213 /* Return the name of the executable file as a string.
 214    ERR nonzero means get error if there is none specified;
 215    otherwise return 0 in that case.  */
 216
 217 char *
 218 get_exec_file (int err)
 219 {
 220   if (exec_bfd)
 221     return bfd_get_filename (exec_bfd);
 222   if (!err)
 223     return NULL;
 224
 225   error ("No executable file specified.\n\
 226 Use the \"file\" or \"exec-file\" command.");
 227   return NULL;
 228 }
 229 \f
 230
 231 /* Report a memory error with error().  */
 232
 233 void
 234 memory_error (int status, CORE_ADDR memaddr)
 235 {
 236   struct ui_file *tmp_stream = mem_fileopen ();
 237   make_cleanup_ui_file_delete (tmp_stream);
 238
 239   if (status == EIO)
 240     {
 241       /* Actually, address between memaddr and memaddr + len
 242          was out of bounds. */
 243       fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
 244       print_address_numeric (memaddr, 1, tmp_stream);
 245     }
 246   else
 247     {
 248       fprintf_filtered (tmp_stream, "Error accessing memory address ");
 249       print_address_numeric (memaddr, 1, tmp_stream);
 250       fprintf_filtered (tmp_stream, ": %s.",
 251                        safe_strerror (status));
 252     }
 253
 254   error_stream (tmp_stream);
 255 }
 256
 257 /* Same as target_read_memory, but report an error if can't read.  */
 258 void
 259 read_memory (CORE_ADDR memaddr, char *myaddr, int len)
 260 {
 261   int status;
 262   status = target_read_memory (memaddr, myaddr, len);
 263   if (status != 0)
 264     memory_error (status, memaddr);
 265 }
 266
 267 /* Like target_read_memory, but slightly different parameters.  */
 268 int
 269 dis_asm_read_memory (bfd_vma memaddr, bfd_byte *myaddr, unsigned int len,
 270                      disassemble_info *info)
 271 {
 272   return target_read_memory (memaddr, (char *) myaddr, len);
 273 }
 274
 275 /* Like memory_error with slightly different parameters.  */
 276 void
 277 dis_asm_memory_error (int status, bfd_vma memaddr, disassemble_info *info)
 278 {
 279   memory_error (status, memaddr);
 280 }
 281
 282 /* Like print_address with slightly different parameters.  */
 283 void
 284 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
 285 {
 286   print_address (addr, info->stream);
 287 }
 288
 289 /* Same as target_write_memory, but report an error if can't write.  */
 290 void
 291 write_memory (CORE_ADDR memaddr, char *myaddr, int len)
 292 {
 293   int status;
 294
 295   status = target_write_memory (memaddr, myaddr, len);
 296   if (status != 0)
 297     memory_error (status, memaddr);
 298 }
 299
 300 /* Read an integer from debugged memory, given address and number of bytes.  */
 301
 302 LONGEST
 303 read_memory_integer (CORE_ADDR memaddr, int len)
 304 {
 305   char buf[sizeof (LONGEST)];
 306
 307   read_memory (memaddr, buf, len);
 308   return extract_signed_integer (buf, len);
 309 }
 310
 311 ULONGEST
 312 read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
 313 {
 314   char buf[sizeof (ULONGEST)];
 315
 316   read_memory (memaddr, buf, len);
 317   return extract_unsigned_integer (buf, len);
 318 }
 319
 320 void
 321 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
 322 {
 323   register char *cp;
 324   register int i;
 325   int cnt;
 326
 327   cp = buffer;
 328   while (1)
 329     {
 330       if (cp - buffer >= max_len)
 331         {
 332           buffer[max_len - 1] = '\0';
 333           break;
 334         }
 335       cnt = max_len - (cp - buffer);
 336       if (cnt > 8)
 337         cnt = 8;
 338       read_memory (memaddr + (int) (cp - buffer), cp, cnt);
 339       for (i = 0; i < cnt && *cp; i++, cp++)
 340         ;                       /* null body */
 341
 342       if (i < cnt && !*cp)
 343         break;
 344     }
 345 }
 346 \f
 347
 348 #if 0
 349 /* Enable after 4.12.  It is not tested.  */
 350
 351 /* Search code.  Targets can just make this their search function, or
 352    if the protocol has a less general search function, they can call this
 353    in the cases it can't handle.  */
 354 void
 355 generic_search (int len, char *data, char *mask, CORE_ADDR startaddr,
 356                 int increment, CORE_ADDR lorange, CORE_ADDR hirange,
 357                 CORE_ADDR *addr_found, char *data_found)
 358 {
 359   int i;
 360   CORE_ADDR curaddr = startaddr;
 361
 362   while (curaddr >= lorange && curaddr < hirange)
 363     {
 364       read_memory (curaddr, data_found, len);
 365       for (i = 0; i < len; ++i)
 366         if ((data_found[i] & mask[i]) != data[i])
 367           goto try_again;
 368       /* It matches.  */
 369       *addr_found = curaddr;
 370       return;
 371
 372     try_again:
 373       curaddr += increment;
 374     }
 375   *addr_found = (CORE_ADDR) 0;
 376   return;
 377 }
 378 #endif /* 0 */
 379 \f
 380 /* The current default bfd target.  Points to storage allocated for
 381    gnutarget_string.  */
 382 char *gnutarget;
 383
 384 /* Same thing, except it is "auto" not NULL for the default case.  */
 385 static char *gnutarget_string;
 386
 387 static void set_gnutarget_command (char *, int, struct cmd_list_element *);
 388
 389 static void
 390 set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
 391 {
 392   if (STREQ (gnutarget_string, "auto"))
 393     gnutarget = NULL;
 394   else
 395     gnutarget = gnutarget_string;
 396 }
 397
 398 /* Set the gnutarget.  */
 399 void
 400 set_gnutarget (char *newtarget)
 401 {
 402   if (gnutarget_string != NULL)
 403     xfree (gnutarget_string);
 404   gnutarget_string = savestring (newtarget, strlen (newtarget));
 405   set_gnutarget_command (NULL, 0, NULL);
 406 }
 407
 408 void
 409 _initialize_core (void)
 410 {
 411   struct cmd_list_element *c;
 412   c = add_cmd ("core-file", class_files, core_file_command,
 413                "Use FILE as core dump for examining memory and registers.\n\
 414 No arg means have no core file.  This command has been superseded by the\n\
 415 `target core' and `detach' commands.", &cmdlist);
 416   c->completer = filename_completer;
 417
 418   c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
 419                    (char *) &gnutarget_string,
 420                    "Set the current BFD target.\n\
 421 Use `set gnutarget auto' to specify automatic detection.",
 422                    &setlist);
 423   c->function.sfunc = set_gnutarget_command;
 424   add_show_from_set (c, &showlist);
 425
 426   if (getenv ("GNUTARGET"))
 427     set_gnutarget (getenv ("GNUTARGET"));
 428   else
 429     set_gnutarget ("auto");
 430 }