gdb/corefile.c

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