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