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