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