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