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,
  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 PARAMS ((void));
  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 \f
  64
  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 \f
 108
 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)
 222     return bfd_get_filename (exec_bfd);
 223   if (!err)
 224     return NULL;
 225
 226   error ("No executable file specified.\n\
 227 Use the \"file\" or \"exec-file\" command.");
 228   return NULL;
 229 }
 230 \f
 231
 232 /* Report a memory error with error().  */
 233
 234 void
 235 memory_error (status, memaddr)
 236      int status;
 237      CORE_ADDR memaddr;
 238 {
 239   GDB_FILE *tmp_stream = tui_sfileopen (130);
 240   make_cleanup_gdb_file_delete (tmp_stream);
 241
 242   error_begin ();
 243
 244   if (status == EIO)
 245     {
 246       /* Actually, address between memaddr and memaddr + len
 247          was out of bounds. */
 248       fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
 249       print_address_numeric (memaddr, 1, tmp_stream);
 250     }
 251   else
 252     {
 253       fprintf_filtered (tmp_stream, "Error accessing memory address ");
 254       print_address_numeric (memaddr, 1, tmp_stream);
 255       fprintf_filtered (tmp_stream, ": %s.",
 256                        safe_strerror (status));
 257     }
 258
 259   error_stream (tmp_stream);
 260 }
 261
 262 /* Same as target_read_memory, but report an error if can't read.  */
 263 void
 264 read_memory (memaddr, myaddr, len)
 265      CORE_ADDR memaddr;
 266      char *myaddr;
 267      int len;
 268 {
 269   int status;
 270   status = target_read_memory (memaddr, myaddr, len);
 271   if (status != 0)
 272     memory_error (status, memaddr);
 273 }
 274
 275 void
 276 read_memory_section (memaddr, myaddr, len, bfd_section)
 277      CORE_ADDR memaddr;
 278      char *myaddr;
 279      int len;
 280      asection *bfd_section;
 281 {
 282   int status;
 283   status = target_read_memory_section (memaddr, myaddr, len, bfd_section);
 284   if (status != 0)
 285     memory_error (status, memaddr);
 286 }
 287
 288 /* Like target_read_memory, but slightly different parameters.  */
 289
 290 int
 291 dis_asm_read_memory (memaddr, myaddr, len, info)
 292      bfd_vma memaddr;
 293      bfd_byte *myaddr;
 294      int len;
 295      disassemble_info *info;
 296 {
 297   return target_read_memory (memaddr, (char *) myaddr, len);
 298 }
 299
 300 /* Like memory_error with slightly different parameters.  */
 301 void
 302 dis_asm_memory_error (status, memaddr, info)
 303      int status;
 304      bfd_vma memaddr;
 305      disassemble_info *info;
 306 {
 307   memory_error (status, memaddr);
 308 }
 309
 310 /* Like print_address with slightly different parameters.  */
 311 void
 312 dis_asm_print_address (addr, info)
 313      bfd_vma addr;
 314      struct disassemble_info *info;
 315 {
 316   print_address (addr, info->stream);
 317 }
 318
 319 /* Same as target_write_memory, but report an error if can't write.  */
 320 void
 321 write_memory (memaddr, myaddr, len)
 322      CORE_ADDR memaddr;
 323      char *myaddr;
 324      int len;
 325 {
 326   int status;
 327
 328   status = target_write_memory (memaddr, myaddr, len);
 329   if (status != 0)
 330     memory_error (status, memaddr);
 331 }
 332
 333 /* Read an integer from debugged memory, given address and number of bytes.  */
 334
 335 LONGEST
 336 read_memory_integer (memaddr, len)
 337      CORE_ADDR memaddr;
 338      int len;
 339 {
 340   char buf[sizeof (LONGEST)];
 341
 342   read_memory (memaddr, buf, len);
 343   return extract_signed_integer (buf, len);
 344 }
 345
 346 ULONGEST
 347 read_memory_unsigned_integer (memaddr, len)
 348      CORE_ADDR memaddr;
 349      int len;
 350 {
 351   char buf[sizeof (ULONGEST)];
 352
 353   read_memory (memaddr, buf, len);
 354   return extract_unsigned_integer (buf, len);
 355 }
 356
 357 void
 358 read_memory_string (memaddr, buffer, max_len)
 359      CORE_ADDR memaddr;
 360      char *buffer;
 361      int max_len;
 362 {
 363   register char *cp;
 364   register int i;
 365   int cnt;
 366
 367   cp = buffer;
 368   while (1)
 369     {
 370       if (cp - buffer >= max_len)
 371         {
 372           buffer[max_len - 1] = '\0';
 373           break;
 374         }
 375       cnt = max_len - (cp - buffer);
 376       if (cnt > 8)
 377         cnt = 8;
 378       read_memory (memaddr + (int) (cp - buffer), cp, cnt);
 379       for (i = 0; i < cnt && *cp; i++, cp++)
 380         ;                       /* null body */
 381
 382       if (i < cnt && !*cp)
 383         break;
 384     }
 385 }
 386 \f
 387
 388 #if 0
 389 /* Enable after 4.12.  It is not tested.  */
 390
 391 /* Search code.  Targets can just make this their search function, or
 392    if the protocol has a less general search function, they can call this
 393    in the cases it can't handle.  */
 394 void
 395 generic_search (len, data, mask, startaddr, increment, lorange, hirange
 396                 addr_found, data_found)
 397      int len;
 398      char *data;
 399      char *mask;
 400      CORE_ADDR startaddr;
 401      int increment;
 402      CORE_ADDR lorange;
 403      CORE_ADDR hirange;
 404      CORE_ADDR *addr_found;
 405      char *data_found;
 406 {
 407   int i;
 408   CORE_ADDR curaddr = startaddr;
 409
 410   while (curaddr >= lorange && curaddr < hirange)
 411     {
 412       read_memory (curaddr, data_found, len);
 413       for (i = 0; i < len; ++i)
 414         if ((data_found[i] & mask[i]) != data[i])
 415           goto try_again;
 416       /* It matches.  */
 417       *addr_found = curaddr;
 418       return;
 419
 420     try_again:
 421       curaddr += increment;
 422     }
 423   *addr_found = (CORE_ADDR) 0;
 424   return;
 425 }
 426 #endif /* 0 */
 427 \f
 428 /* The current default bfd target.  Points to storage allocated for
 429    gnutarget_string.  */
 430 char *gnutarget;
 431
 432 /* Same thing, except it is "auto" not NULL for the default case.  */
 433 static char *gnutarget_string;
 434
 435 static void set_gnutarget_command
 436   PARAMS ((char *, int, struct cmd_list_element *));
 437
 438 static void
 439 set_gnutarget_command (ignore, from_tty, c)
 440      char *ignore;
 441      int from_tty;
 442      struct cmd_list_element *c;
 443 {
 444   if (STREQ (gnutarget_string, "auto"))
 445     gnutarget = NULL;
 446   else
 447     gnutarget = gnutarget_string;
 448 }
 449
 450 /* Set the gnutarget.  */
 451 void
 452 set_gnutarget (newtarget)
 453      char *newtarget;
 454 {
 455   if (gnutarget_string != NULL)
 456     free (gnutarget_string);
 457   gnutarget_string = savestring (newtarget, strlen (newtarget));
 458   set_gnutarget_command (NULL, 0, NULL);
 459 }
 460
 461 void
 462 _initialize_core ()
 463 {
 464   struct cmd_list_element *c;
 465   c = add_cmd ("core-file", class_files, core_file_command,
 466                "Use FILE as core dump for examining memory and registers.\n\
 467 No arg means have no core file.  This command has been superseded by the\n\
 468 `target core' and `detach' commands.", &cmdlist);
 469   c->completer = filename_completer;
 470
 471   c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
 472                    (char *) &gnutarget_string,
 473                    "Set the current BFD target.\n\
 474 Use `set gnutarget auto' to specify automatic detection.",
 475                    &setlist);
 476   c->function.sfunc = set_gnutarget_command;
 477   add_show_from_set (c, &showlist);
 478
 479   if (getenv ("GNUTARGET"))
 480     set_gnutarget (getenv ("GNUTARGET"));
 481   else
 482     set_gnutarget ("auto");
 483 }