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 \f
 329 #if 0
 330 /* Enable after 4.12.  It is not tested.  */
 331
 332 /* Search code.  Targets can just make this their search function, or
 333    if the protocol has a less general search function, they can call this
 334    in the cases it can't handle.  */
 335 void
 336 generic_search (len, data, mask, startaddr, increment, lorange, hirange
 337                 addr_found, data_found)
 338      int len;
 339      char *data;
 340      char *mask;
 341      CORE_ADDR startaddr;
 342      int increment;
 343      CORE_ADDR lorange;
 344      CORE_ADDR hirange;
 345      CORE_ADDR *addr_found;
 346      char *data_found;
 347 {
 348   int i;
 349   CORE_ADDR curaddr = startaddr;
 350
 351   while (curaddr >= lorange && curaddr < hirange)
 352     {
 353       read_memory (curaddr, data_found, len);
 354       for (i = 0; i < len; ++i)
 355         if ((data_found[i] & mask[i]) != data[i])
 356           goto try_again;
 357       /* It matches.  */
 358       *addr_found = curaddr;
 359       return;
 360
 361     try_again:
 362       curaddr += increment;
 363     }
 364   *addr_found = (CORE_ADDR)0;
 365   return;
 366 }
 367 #endif /* 0 */
 368 \f
 369 /* The current default bfd target.  Points to storage allocated for
 370    gnutarget_string.  */
 371 char *gnutarget;
 372
 373 /* Same thing, except it is "auto" not NULL for the default case.  */
 374 static char *gnutarget_string;
 375
 376 static void set_gnutarget_command
 377   PARAMS ((char *, int, struct cmd_list_element *));
 378
 379 static void
 380 set_gnutarget_command (ignore, from_tty, c)
 381      char *ignore;
 382      int from_tty;
 383      struct cmd_list_element *c;
 384 {
 385   if (STREQ (gnutarget_string, "auto"))
 386     gnutarget = NULL;
 387   else
 388     gnutarget = gnutarget_string;
 389 }
 390
 391 /* Set the gnutarget.  */
 392 void
 393 set_gnutarget (newtarget)
 394      char *newtarget;
 395 {
 396   if (gnutarget_string != NULL)
 397     free (gnutarget_string);
 398   gnutarget_string = savestring (newtarget, strlen (newtarget));
 399   set_gnutarget_command (NULL, 0, NULL);
 400 }
 401
 402 void
 403 _initialize_core()
 404 {
 405   struct cmd_list_element *c;
 406   c = add_cmd ("core-file", class_files, core_file_command,
 407                "Use FILE as core dump for examining memory and registers.\n\
 408 No arg means have no core file.  This command has been superseded by the\n\
 409 `target core' and `detach' commands.", &cmdlist);
 410   c->completer = filename_completer;
 411
 412   c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
 413                   (char *) &gnutarget_string,
 414                   "Set the current BFD target.\n\
 415 Use `set gnutarget auto' to specify automatic detection.",
 416                   &setlist);
 417   c->function.sfunc = set_gnutarget_command;
 418   add_show_from_set (c, &showlist);
 419
 420   if (getenv ("GNUTARGET"))
 421     set_gnutarget (getenv ("GNUTARGET"));
 422   else
 423     set_gnutarget ("auto");
 424 }