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
  41 /* Local function declarations.  */
  42
  43 extern void _initialize_core (void);
  44 static void call_extra_exec_file_hooks (char *filename);
  45
  46 /* You can have any number of hooks for `exec_file_command' command to call.
  47    If there's only one hook, it is set in exec_file_display hook.
  48    If there are two or more hooks, they are set in exec_file_extra_hooks[],
  49    and exec_file_display_hook is set to a function that calls all of them.
  50    This extra complexity is needed to preserve compatibility with
  51    old code that assumed that only one hook could be set, and which called
  52    exec_file_display_hook directly.  */
  53
  54 typedef void (*hook_type) (char *);
  55
  56 hook_type exec_file_display_hook;       /* the original hook */
  57 static hook_type *exec_file_extra_hooks;        /* array of additional hooks */
  58 static int exec_file_hook_count = 0;    /* size of array */
  59
  60 /* Binary file diddling handle for the core file.  */
  61
  62 bfd *core_bfd = NULL;
  63 \f
  64
  65 /* Backward compatability with old way of specifying core files.  */
  66
  67 void
  68 core_file_command (char *filename, int from_tty)
  69 {
  70   struct target_ops *t;
  71
  72   dont_repeat ();               /* Either way, seems bogus. */
  73
  74   t = find_core_target ();
  75   if (t != NULL)
  76     if (!filename)
  77       (t->to_detach) (filename, from_tty);
  78     else
  79       {
  80         /* Yes, we were given the path of a core file.  Do we already
  81            have a symbol file?  If not, can we determine it from the
  82            core file?  If we can, do so.
  83          */
  84 #ifdef HPUXHPPA
  85         if (symfile_objfile == NULL)
  86           {
  87             char *symfile;
  88             symfile = t->to_core_file_to_sym_file (filename);
  89             if (symfile)
  90               {
  91                 char *symfile_copy = xstrdup (symfile);
  92
  93                 make_cleanup (free, symfile_copy);
  94                 symbol_file_command (symfile_copy, from_tty);
  95               }
  96             else
  97               warning ("Unknown symbols for '%s'; use the 'symbol-file' command.", filename);
  98           }
  99 #endif
 100         (t->to_open) (filename, from_tty);
 101       }
 102   else
 103     error ("GDB can't read core files on this machine.");
 104 }
 105 \f
 106
 107 /* If there are two or more functions that wish to hook into exec_file_command,
 108  * this function will call all of the hook functions. */
 109
 110 static void
 111 call_extra_exec_file_hooks (char *filename)
 112 {
 113   int i;
 114
 115   for (i = 0; i < exec_file_hook_count; i++)
 116     (*exec_file_extra_hooks[i]) (filename);
 117 }
 118
 119 /* Call this to specify the hook for exec_file_command to call back.
 120    This is called from the x-window display code.  */
 121
 122 void
 123 specify_exec_file_hook (hook)
 124      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 (free, 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 (len, data, mask, startaddr, increment, lorange, hirange
 353                 addr_found, data_found)
 354      int len;
 355      char *data;
 356      char *mask;
 357      CORE_ADDR startaddr;
 358      int increment;
 359      CORE_ADDR lorange;
 360      CORE_ADDR hirange;
 361      CORE_ADDR *addr_found;
 362      char *data_found;
 363 {
 364   int i;
 365   CORE_ADDR curaddr = startaddr;
 366
 367   while (curaddr >= lorange && curaddr < hirange)
 368     {
 369       read_memory (curaddr, data_found, len);
 370       for (i = 0; i < len; ++i)
 371         if ((data_found[i] & mask[i]) != data[i])
 372           goto try_again;
 373       /* It matches.  */
 374       *addr_found = curaddr;
 375       return;
 376
 377     try_again:
 378       curaddr += increment;
 379     }
 380   *addr_found = (CORE_ADDR) 0;
 381   return;
 382 }
 383 #endif /* 0 */
 384 \f
 385 /* The current default bfd target.  Points to storage allocated for
 386    gnutarget_string.  */
 387 char *gnutarget;
 388
 389 /* Same thing, except it is "auto" not NULL for the default case.  */
 390 static char *gnutarget_string;
 391
 392 static void set_gnutarget_command (char *, int, struct cmd_list_element *);
 393
 394 static void
 395 set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
 396 {
 397   if (STREQ (gnutarget_string, "auto"))
 398     gnutarget = NULL;
 399   else
 400     gnutarget = gnutarget_string;
 401 }
 402
 403 /* Set the gnutarget.  */
 404 void
 405 set_gnutarget (char *newtarget)
 406 {
 407   if (gnutarget_string != NULL)
 408     free (gnutarget_string);
 409   gnutarget_string = savestring (newtarget, strlen (newtarget));
 410   set_gnutarget_command (NULL, 0, NULL);
 411 }
 412
 413 void
 414 _initialize_core (void)
 415 {
 416   struct cmd_list_element *c;
 417   c = add_cmd ("core-file", class_files, core_file_command,
 418                "Use FILE as core dump for examining memory and registers.\n\
 419 No arg means have no core file.  This command has been superseded by the\n\
 420 `target core' and `detach' commands.", &cmdlist);
 421   c->completer = filename_completer;
 422
 423   c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
 424                    (char *) &gnutarget_string,
 425                    "Set the current BFD target.\n\
 426 Use `set gnutarget auto' to specify automatic detection.",
 427                    &setlist);
 428   c->function.sfunc = set_gnutarget_command;
 429   add_show_from_set (c, &showlist);
 430
 431   if (getenv ("GNUTARGET"))
 432     set_gnutarget (getenv ("GNUTARGET"));
 433   else
 434     set_gnutarget ("auto");
 435 }