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
  37 extern char registers[];
  38
  39 /* Local function declarations.  */
  40
  41 static void call_extra_exec_file_hooks PARAMS ((char *filename));
  42
  43 /* You can have any number of hooks for `exec_file_command' command to call.
  44    If there's only one hook, it is set in exec_file_display hook.
  45    If there are two or more hooks, they are set in exec_file_extra_hooks[],
  46    and exec_file_display_hook is set to a function that calls all of them.
  47    This extra complexity is needed to preserve compatibility with
  48    old code that assumed that only one hook could be set, and which called
  49    exec_file_display_hook directly.  */
  50
  51 typedef void (*hook_type) PARAMS ((char *));
  52
  53 hook_type exec_file_display_hook;               /* the original hook */
  54 static hook_type *exec_file_extra_hooks;        /* array of additional hooks */
  55 static int exec_file_hook_count = 0;            /* size of array */
  56
  57 /* Binary file diddling handle for the core file.  */
  58
  59 bfd *core_bfd = NULL;
  60
  61 \f
  62 /* Backward compatability with old way of specifying core files.  */
  63
  64 void
  65 core_file_command (filename, from_tty)
  66      char *filename;
  67      int from_tty;
  68 {
  69   struct target_ops *t;
  70
  71   dont_repeat ();                       /* Either way, seems bogus. */
  72
  73   t = find_core_target ();
  74   if (t != NULL)
  75     if (!filename)
  76       (t->to_detach) (filename, from_tty);
  77     else
  78       (t->to_open) (filename, from_tty);
  79   else
  80     error ("GDB can't read core files on this machine.");
  81 }
  82
  83 \f
  84 /* If there are two or more functions that wish to hook into exec_file_command,
  85  * this function will call all of the hook functions. */
  86
  87 static void
  88 call_extra_exec_file_hooks (filename)
  89      char *filename;
  90 {
  91   int i;
  92
  93   for (i = 0; i < exec_file_hook_count; i++)
  94     (*exec_file_extra_hooks[i])(filename);
  95 }
  96
  97 /* Call this to specify the hook for exec_file_command to call back.
  98    This is called from the x-window display code.  */
  99
 100 void
 101 specify_exec_file_hook (hook)
 102      void (*hook) PARAMS ((char *));
 103 {
 104   hook_type *new_array;
 105
 106   if (exec_file_display_hook != NULL)
 107     {
 108       /* There's already a hook installed.  Arrange to have both it
 109        * and the subsequent hooks called. */
 110       if (exec_file_hook_count == 0)
 111         {
 112           /* If this is the first extra hook, initialize the hook array. */
 113           exec_file_extra_hooks = (hook_type *) xmalloc (sizeof(hook_type));
 114           exec_file_extra_hooks[0] = exec_file_display_hook;
 115           exec_file_display_hook = call_extra_exec_file_hooks;
 116           exec_file_hook_count = 1;
 117         }
 118
 119       /* Grow the hook array by one and add the new hook to the end.
 120          Yes, it's inefficient to grow it by one each time but since
 121          this is hardly ever called it's not a big deal.  */
 122       exec_file_hook_count++;
 123       new_array =
 124         (hook_type *) xrealloc (exec_file_extra_hooks,
 125                                 exec_file_hook_count * sizeof(hook_type));
 126       exec_file_extra_hooks = new_array;
 127       exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
 128     }
 129   else
 130     exec_file_display_hook = hook;
 131 }
 132
 133 /* The exec file must be closed before running an inferior.
 134    If it is needed again after the inferior dies, it must
 135    be reopened.  */
 136
 137 void
 138 close_exec_file ()
 139 {
 140 #ifdef FIXME
 141   if (exec_bfd)
 142     bfd_tempclose (exec_bfd);
 143 #endif
 144 }
 145
 146 void
 147 reopen_exec_file ()
 148 {
 149 #ifdef FIXME
 150   if (exec_bfd)
 151     bfd_reopen (exec_bfd);
 152 #endif
 153 }
 154 \f
 155 /* If we have both a core file and an exec file,
 156    print a warning if they don't go together.  */
 157
 158 void
 159 validate_files ()
 160 {
 161   if (exec_bfd && core_bfd)
 162     {
 163       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 164         warning ("core file may not match specified executable file.");
 165       else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
 166         warning ("exec file is newer than core file.");
 167     }
 168 }
 169
 170 /* Return the name of the executable file as a string.
 171    ERR nonzero means get error if there is none specified;
 172    otherwise return 0 in that case.  */
 173
 174 char *
 175 get_exec_file (err)
 176      int err;
 177 {
 178   if (exec_bfd) return bfd_get_filename(exec_bfd);
 179   if (!err)     return NULL;
 180
 181   error ("No executable file specified.\n\
 182 Use the \"file\" or \"exec-file\" command.");
 183   return NULL;
 184 }
 185
 186 \f
 187 /* Report a memory error with error().  */
 188
 189 void
 190 memory_error (status, memaddr)
 191      int status;
 192      CORE_ADDR memaddr;
 193 {
 194   if (status == EIO)
 195     {
 196       /* Actually, address between memaddr and memaddr + len
 197          was out of bounds. */
 198       error_begin ();
 199       printf_filtered ("Cannot access memory at address ");
 200       print_address_numeric (memaddr, 1, gdb_stdout);
 201       printf_filtered (".\n");
 202       return_to_top_level (RETURN_ERROR);
 203     }
 204   else
 205     {
 206       error_begin ();
 207       printf_filtered ("Error accessing memory address ");
 208       print_address_numeric (memaddr, 1, gdb_stdout);
 209       printf_filtered (": %s.\n",
 210                          safe_strerror (status));
 211       return_to_top_level (RETURN_ERROR);
 212     }
 213 }
 214
 215 /* Same as target_read_memory, but report an error if can't read.  */
 216 void
 217 read_memory (memaddr, myaddr, len)
 218      CORE_ADDR memaddr;
 219      char *myaddr;
 220      int len;
 221 {
 222   int status;
 223   status = target_read_memory (memaddr, myaddr, len);
 224   if (status != 0)
 225     memory_error (status, memaddr);
 226 }
 227
 228 /* Like target_read_memory, but slightly different parameters.  */
 229
 230 int
 231 dis_asm_read_memory (memaddr, myaddr, len, info)
 232      bfd_vma memaddr;
 233      bfd_byte *myaddr;
 234      int len;
 235      disassemble_info *info;
 236 {
 237   return target_read_memory (memaddr, (char *) myaddr, len);
 238 }
 239
 240 /* Like memory_error with slightly different parameters.  */
 241 void
 242 dis_asm_memory_error (status, memaddr, info)
 243      int status;
 244      bfd_vma memaddr;
 245      disassemble_info *info;
 246 {
 247   memory_error (status, memaddr);
 248 }
 249
 250 /* Like print_address with slightly different parameters.  */
 251 void
 252 dis_asm_print_address (addr, info)
 253      bfd_vma addr;
 254      struct disassemble_info *info;
 255 {
 256   print_address (addr, info->stream);
 257 }
 258
 259 /* Same as target_write_memory, but report an error if can't write.  */
 260 void
 261 write_memory (memaddr, myaddr, len)
 262      CORE_ADDR memaddr;
 263      char *myaddr;
 264      int len;
 265 {
 266   int status;
 267
 268   status = target_write_memory (memaddr, myaddr, len);
 269   if (status != 0)
 270     memory_error (status, memaddr);
 271 }
 272
 273 /* Read an integer from debugged memory, given address and number of bytes.  */
 274
 275 LONGEST
 276 read_memory_integer (memaddr, len)
 277      CORE_ADDR memaddr;
 278      int len;
 279 {
 280   char buf[sizeof (LONGEST)];
 281
 282   read_memory (memaddr, buf, len);
 283   return extract_signed_integer (buf, len);
 284 }
 285
 286 unsigned LONGEST
 287 read_memory_unsigned_integer (memaddr, len)
 288      CORE_ADDR memaddr;
 289      int len;
 290 {
 291   char buf[sizeof (unsigned LONGEST)];
 292
 293   read_memory (memaddr, buf, len);
 294   return extract_unsigned_integer (buf, len);
 295 }
 296 \f
 297 #if 0
 298 /* Enable after 4.12.  It is not tested.  */
 299
 300 /* Search code.  Targets can just make this their search function, or
 301    if the protocol has a less general search function, they can call this
 302    in the cases it can't handle.  */
 303 void
 304 generic_search (len, data, mask, startaddr, increment, lorange, hirange
 305                 addr_found, data_found)
 306      int len;
 307      char *data;
 308      char *mask;
 309      CORE_ADDR startaddr;
 310      int increment;
 311      CORE_ADDR lorange;
 312      CORE_ADDR hirange;
 313      CORE_ADDR *addr_found;
 314      char *data_found;
 315 {
 316   int i;
 317   CORE_ADDR curaddr = startaddr;
 318
 319   while (curaddr >= lorange && curaddr < hirange)
 320     {
 321       read_memory (curaddr, data_found, len);
 322       for (i = 0; i < len; ++i)
 323         if ((data_found[i] & mask[i]) != data[i])
 324           goto try_again;
 325       /* It matches.  */
 326       *addr_found = curaddr;
 327       return;
 328
 329     try_again:
 330       curaddr += increment;
 331     }
 332   *addr_found = (CORE_ADDR)0;
 333   return;
 334 }
 335 #endif /* 0 */
 336 \f
 337 /* The current default bfd target.  Points to storage allocated for
 338    gnutarget_string.  */
 339 char *gnutarget;
 340
 341 /* Same thing, except it is "auto" not NULL for the default case.  */
 342 static char *gnutarget_string;
 343
 344 static void set_gnutarget_command
 345   PARAMS ((char *, int, struct cmd_list_element *));
 346
 347 static void
 348 set_gnutarget_command (ignore, from_tty, c)
 349      char *ignore;
 350      int from_tty;
 351      struct cmd_list_element *c;
 352 {
 353   if (STREQ (gnutarget_string, "auto"))
 354     gnutarget = NULL;
 355   else
 356     gnutarget = gnutarget_string;
 357 }
 358
 359 /* Set the gnutarget.  */
 360 void
 361 set_gnutarget (newtarget)
 362      char *newtarget;
 363 {
 364   if (gnutarget_string != NULL)
 365     free (gnutarget_string);
 366   gnutarget_string = savestring (newtarget, strlen (newtarget));
 367   set_gnutarget_command (NULL, 0, NULL);
 368 }
 369
 370 void
 371 _initialize_core()
 372 {
 373   struct cmd_list_element *c;
 374   c = add_cmd ("core-file", class_files, core_file_command,
 375                "Use FILE as core dump for examining memory and registers.\n\
 376 No arg means have no core file.  This command has been superseded by the\n\
 377 `target core' and `detach' commands.", &cmdlist);
 378   c->completer = filename_completer;
 379
 380   c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
 381                   (char *) &gnutarget_string,
 382                   "Set the current BFD target.\n\
 383 Use `set gnutarget auto' to specify automatic detection.",
 384                   &setlist);
 385   c->function.sfunc = set_gnutarget_command;
 386   add_show_from_set (c, &showlist);
 387
 388   if (getenv ("GNUTARGET"))
 389     set_gnutarget (getenv ("GNUTARGET"));
 390   else
 391     set_gnutarget ("auto");
 392 }