gdb/corefile.c

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