gdb/core.c

   1 /* Core dump and executable file functions above target vector, for GDB.
   2    Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include <errno.h>
  22 #include <signal.h>
  23 #include <fcntl.h>
  24 #include "frame.h"  /* required by inferior.h */
  25 #include "inferior.h"
  26 #include "symtab.h"
  27 #include "command.h"
  28 #include "gdbcmd.h"
  29 #include "bfd.h"
  30 #include "target.h"
  31 #include "gdbcore.h"
  32 #include "dis-asm.h"
  33 #include "language.h"
  34
  35 extern char registers[];
  36
  37 /* Hook for `exec_file_command' command to call.  */
  38
  39 void (*exec_file_display_hook) PARAMS ((char *)) = NULL;
  40
  41 /* Binary file diddling handle for the core file.  */
  42
  43 bfd *core_bfd = NULL;
  44
  45 \f
  46 /* Backward compatability with old way of specifying core files.  */
  47
  48 void
  49 core_file_command (filename, from_tty)
  50      char *filename;
  51      int from_tty;
  52 {
  53   struct target_ops *t;
  54
  55   dont_repeat ();                       /* Either way, seems bogus. */
  56
  57   t = find_core_target ();
  58   if (t != NULL)
  59     if (!filename)
  60       (t->to_detach) (filename, from_tty);
  61     else
  62       (t->to_open) (filename, from_tty);
  63   else
  64     error ("GDB can't read core files on this machine.");
  65 }
  66
  67 \f
  68 /* Call this to specify the hook for exec_file_command to call back.
  69    This is called from the x-window display code.  */
  70
  71 void
  72 specify_exec_file_hook (hook)
  73      void (*hook) PARAMS ((char *));
  74 {
  75   exec_file_display_hook = hook;
  76 }
  77
  78 /* The exec file must be closed before running an inferior.
  79    If it is needed again after the inferior dies, it must
  80    be reopened.  */
  81
  82 void
  83 close_exec_file ()
  84 {
  85 #ifdef FIXME
  86   if (exec_bfd)
  87     bfd_tempclose (exec_bfd);
  88 #endif
  89 }
  90
  91 void
  92 reopen_exec_file ()
  93 {
  94 #ifdef FIXME
  95   if (exec_bfd)
  96     bfd_reopen (exec_bfd);
  97 #endif
  98 }
  99 \f
 100 /* If we have both a core file and an exec file,
 101    print a warning if they don't go together.  */
 102
 103 void
 104 validate_files ()
 105 {
 106   if (exec_bfd && core_bfd)
 107     {
 108       if (!core_file_matches_executable_p (core_bfd, exec_bfd))
 109         warning ("core file may not match specified executable file.");
 110       else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
 111         warning ("exec file is newer than core file.");
 112     }
 113 }
 114
 115 /* Return the name of the executable file as a string.
 116    ERR nonzero means get error if there is none specified;
 117    otherwise return 0 in that case.  */
 118
 119 char *
 120 get_exec_file (err)
 121      int err;
 122 {
 123   if (exec_bfd) return bfd_get_filename(exec_bfd);
 124   if (!err)     return NULL;
 125
 126   error ("No executable file specified.\n\
 127 Use the \"file\" or \"exec-file\" command.");
 128   return NULL;
 129 }
 130
 131 \f
 132 /* Report a memory error with error().  */
 133
 134 void
 135 memory_error (status, memaddr)
 136      int status;
 137      CORE_ADDR memaddr;
 138 {
 139   /* FIXME-32x64--casting CORE_ADDR to unsigned long */
 140   if (status == EIO)
 141     {
 142       /* Actually, address between memaddr and memaddr + len
 143          was out of bounds. */
 144       error ("Cannot access memory at address %s.",
 145              local_hex_string((unsigned long) memaddr));
 146     }
 147   else
 148     {
 149       error ("Error accessing memory address %s: %s.",
 150              local_hex_string ((unsigned long) memaddr),
 151              safe_strerror (status));
 152     }
 153 }
 154
 155 /* Same as target_read_memory, but report an error if can't read.  */
 156 void
 157 read_memory (memaddr, myaddr, len)
 158      CORE_ADDR memaddr;
 159      char *myaddr;
 160      int len;
 161 {
 162   int status;
 163   status = target_read_memory (memaddr, myaddr, len);
 164   if (status != 0)
 165     memory_error (status, memaddr);
 166 }
 167
 168 /* Like target_read_memory, but slightly different parameters.  */
 169
 170 int
 171 dis_asm_read_memory (memaddr, myaddr, len, info)
 172      bfd_vma memaddr;
 173      bfd_byte *myaddr;
 174      int len;
 175      disassemble_info *info;
 176 {
 177   return target_read_memory (memaddr, (char *) myaddr, len);
 178 }
 179
 180 /* Like memory_error with slightly different parameters.  */
 181 void
 182 dis_asm_memory_error (status, memaddr, info)
 183      int status;
 184      bfd_vma memaddr;
 185      disassemble_info *info;
 186 {
 187   memory_error (status, memaddr);
 188 }
 189
 190 /* Like print_address with slightly different parameters.  */
 191 void
 192 dis_asm_print_address (addr, info)
 193      bfd_vma addr;
 194      struct disassemble_info *info;
 195 {
 196   print_address (addr, info->stream);
 197 }
 198
 199 /* Same as target_write_memory, but report an error if can't write.  */
 200 void
 201 write_memory (memaddr, myaddr, len)
 202      CORE_ADDR memaddr;
 203      char *myaddr;
 204      int len;
 205 {
 206   int status;
 207
 208   status = target_write_memory (memaddr, myaddr, len);
 209   if (status != 0)
 210     memory_error (status, memaddr);
 211 }
 212
 213 /* Read an integer from debugged memory, given address and number of bytes.  */
 214
 215 LONGEST
 216 read_memory_integer (memaddr, len)
 217      CORE_ADDR memaddr;
 218      int len;
 219 {
 220   char buf[sizeof (LONGEST)];
 221
 222   read_memory (memaddr, buf, len);
 223   return extract_signed_integer (buf, len);
 224 }
 225
 226 unsigned LONGEST
 227 read_memory_unsigned_integer (memaddr, len)
 228      CORE_ADDR memaddr;
 229      int len;
 230 {
 231   char buf[sizeof (unsigned LONGEST)];
 232
 233   read_memory (memaddr, buf, len);
 234   return extract_unsigned_integer (buf, len);
 235 }
 236 \f
 237 #if 0
 238 /* Enable after 4.12.  It is not tested.  */
 239
 240 /* Search code.  Targets can just make this their search function, or
 241    if the protocol has a less general search function, they can call this
 242    in the cases it can't handle.  */
 243 void
 244 generic_search (len, data, mask, startaddr, increment, lorange, hirange
 245                 addr_found, data_found)
 246      int len;
 247      char *data;
 248      char *mask;
 249      CORE_ADDR startaddr;
 250      int increment;
 251      CORE_ADDR lorange;
 252      CORE_ADDR hirange;
 253      CORE_ADDR *addr_found;
 254      char *data_found;
 255 {
 256   int i;
 257   CORE_ADDR curaddr = startaddr;
 258
 259   while (curaddr >= lorange && curaddr < hirange)
 260     {
 261       read_memory (curaddr, data_found, len);
 262       for (i = 0; i < len; ++i)
 263         if ((data_found[i] & mask[i]) != data[i])
 264           goto try_again;
 265       /* It matches.  */
 266       *addr_found = curaddr;
 267       return;
 268
 269     try_again:
 270       curaddr += increment;
 271     }
 272   *addr_found = (CORE_ADDR)0;
 273   return;
 274 }
 275 #endif /* 0 */
 276 \f
 277 /* The current default bfd target.  Points to storage allocated for
 278    gnutarget_string.  */
 279 char *gnutarget;
 280
 281 /* Same thing, except it is "auto" not NULL for the default case.  */
 282 static char *gnutarget_string;
 283
 284 static void set_gnutarget_command
 285   PARAMS ((char *, int, struct cmd_list_element *));
 286
 287 static void
 288 set_gnutarget_command (ignore, from_tty, c)
 289      char *ignore;
 290      int from_tty;
 291      struct cmd_list_element *c;
 292 {
 293   if (STREQ (gnutarget_string, "auto"))
 294     gnutarget = NULL;
 295   else
 296     gnutarget = gnutarget_string;
 297 }
 298
 299 /* Set the gnutarget.  */
 300 void
 301 set_gnutarget (newtarget)
 302      char *newtarget;
 303 {
 304   if (gnutarget_string != NULL)
 305     free (gnutarget_string);
 306   gnutarget_string = savestring (newtarget, strlen (newtarget));
 307   set_gnutarget_command (NULL, 0, NULL);
 308 }
 309
 310 void
 311 _initialize_core()
 312 {
 313   struct cmd_list_element *c;
 314   c = add_cmd ("core-file", class_files, core_file_command,
 315                "Use FILE as core dump for examining memory and registers.\n\
 316 No arg means have no core file.  This command has been superseded by the\n\
 317 `target core' and `detach' commands.", &cmdlist);
 318   c->completer = filename_completer;
 319
 320   c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
 321                   (char *) &gnutarget_string,
 322                   "Set the current BFD target.\n\
 323 Use `set gnutarget auto' to specify automatic detection.",
 324                   &setlist);
 325   c->function.sfunc = set_gnutarget_command;
 326   add_show_from_set (c, &showlist);
 327
 328   if (getenv ("GNUTARGET"))
 329     set_gnutarget (getenv ("GNUTARGET"));
 330   else
 331     set_gnutarget ("auto");
 332 }