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