gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
   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 "bfd.h"
  31 #include "target.h"
  32 #include "gdbcore.h"
  33 #include "gdbthread.h"
  34
  35 /* List of all available core_fns.  On gdb startup, each core file register
  36    reader calls add_core_fns() to register information on each core format it
  37    is prepared to read. */
  38
  39 static struct core_fns *core_file_fns = NULL;
  40
  41 static void core_files_info PARAMS ((struct target_ops *));
  42
  43 #ifdef SOLIB_ADD
  44 static int solib_add_stub PARAMS ((char *));
  45 #endif
  46
  47 static void core_open PARAMS ((char *, int));
  48
  49 static void core_detach PARAMS ((char *, int));
  50
  51 static void core_close PARAMS ((int));
  52
  53 static void get_core_registers PARAMS ((int));
  54
  55 static void add_to_thread_list PARAMS ((bfd *, asection *, PTR));
  56
  57 static int ignore PARAMS ((CORE_ADDR, char *));
  58
  59 /* Link a new core_fns into the global core_file_fns list.  Called on gdb
  60    startup by the _initialize routine in each core file register reader, to
  61    register information about each format the the reader is prepared to
  62    handle. */
  63
  64 void
  65 add_core_fns (cf)
  66      struct core_fns *cf;
  67 {
  68   cf -> next = core_file_fns;
  69   core_file_fns = cf;
  70 }
  71
  72
  73 /* Discard all vestiges of any previous core file and mark data and stack
  74    spaces as empty.  */
  75
  76 /* ARGSUSED */
  77 static void
  78 core_close (quitting)
  79      int quitting;
  80 {
  81   char *name;
  82
  83   if (core_bfd)
  84     {
  85       inferior_pid = 0;         /* Avoid confusion from thread stuff */
  86
  87       name = bfd_get_filename (core_bfd);
  88       if (!bfd_close (core_bfd))
  89         warning ("cannot close \"%s\": %s",
  90                  name, bfd_errmsg (bfd_get_error ()));
  91       free (name);
  92       core_bfd = NULL;
  93 #ifdef CLEAR_SOLIB
  94       CLEAR_SOLIB ();
  95 #endif
  96       if (core_ops.to_sections)
  97         {
  98           free ((PTR)core_ops.to_sections);
  99           core_ops.to_sections = NULL;
 100           core_ops.to_sections_end = NULL;
 101         }
 102     }
 103 }
 104
 105 #ifdef SOLIB_ADD
 106 /* Stub function for catch_errors around shared library hacking.  FROM_TTYP
 107    is really an int * which points to from_tty.  */
 108
 109 static int
 110 solib_add_stub (from_ttyp)
 111      char *from_ttyp;
 112 {
 113   SOLIB_ADD (NULL, *(int *)from_ttyp, &current_target);
 114   re_enable_breakpoints_in_shlibs ();
 115   return 0;
 116 }
 117 #endif /* SOLIB_ADD */
 118
 119 /* Look for sections whose names start with `.reg/' so that we can extract the
 120    list of threads in a core file.  */
 121
 122 static void
 123 add_to_thread_list (abfd, asect, reg_sect_arg)
 124      bfd *abfd;
 125      asection *asect;
 126      PTR reg_sect_arg;
 127 {
 128   int thread_id;
 129   asection *reg_sect = (asection *) reg_sect_arg;
 130
 131   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 132     return;
 133
 134   thread_id = atoi (bfd_section_name (abfd, asect) + 5);
 135
 136   add_thread (thread_id);
 137
 138 /* Warning, Will Robinson, looking at BFD private data! */
 139
 140   if (reg_sect != NULL
 141       && asect->filepos == reg_sect->filepos) /* Did we find .reg? */
 142     inferior_pid = thread_id;   /* Yes, make it current */
 143 }
 144
 145 /* This routine opens and sets up the core file bfd.  */
 146
 147 static void
 148 core_open (filename, from_tty)
 149      char *filename;
 150      int from_tty;
 151 {
 152   const char *p;
 153   int siggy;
 154   struct cleanup *old_chain;
 155   char *temp;
 156   bfd *temp_bfd;
 157   int ontop;
 158   int scratch_chan;
 159
 160   target_preopen (from_tty);
 161   if (!filename)
 162     {
 163       error (core_bfd ?
 164        "No core file specified.  (Use `detach' to stop debugging a core file.)"
 165      : "No core file specified.");
 166     }
 167
 168   filename = tilde_expand (filename);
 169   if (filename[0] != '/')
 170     {
 171       temp = concat (current_directory, "/", filename, NULL);
 172       free (filename);
 173       filename = temp;
 174     }
 175
 176   old_chain = make_cleanup (free, filename);
 177
 178   scratch_chan = open (filename, write_files ? O_RDWR : O_RDONLY, 0);
 179   if (scratch_chan < 0)
 180     perror_with_name (filename);
 181
 182   temp_bfd = bfd_fdopenr (filename, gnutarget, scratch_chan);
 183   if (temp_bfd == NULL)
 184     perror_with_name (filename);
 185
 186   if (!bfd_check_format (temp_bfd, bfd_core))
 187     {
 188       /* Do it after the err msg */
 189       /* FIXME: should be checking for errors from bfd_close (for one thing,
 190          on error it does not free all the storage associated with the
 191          bfd).  */
 192       make_cleanup (bfd_close, temp_bfd);
 193       error ("\"%s\" is not a core dump: %s",
 194              filename, bfd_errmsg (bfd_get_error ()));
 195     }
 196
 197   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 198
 199   discard_cleanups (old_chain);         /* Don't free filename any more */
 200   unpush_target (&core_ops);
 201   core_bfd = temp_bfd;
 202   old_chain = make_cleanup (core_close, core_bfd);
 203
 204   validate_files ();
 205
 206   /* Find the data section */
 207   if (build_section_table (core_bfd, &core_ops.to_sections,
 208                            &core_ops.to_sections_end))
 209     error ("\"%s\": Can't find sections: %s",
 210            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 211
 212   ontop = !push_target (&core_ops);
 213   discard_cleanups (old_chain);
 214
 215   p = bfd_core_file_failing_command (core_bfd);
 216   if (p)
 217     printf_filtered ("Core was generated by `%s'.\n", p);
 218
 219   siggy = bfd_core_file_failing_signal (core_bfd);
 220   if (siggy > 0)
 221     printf_filtered ("Program terminated with signal %d, %s.\n", siggy,
 222                      safe_strsignal (siggy));
 223
 224   /* Build up thread list from BFD sections. */
 225
 226   init_thread_list ();
 227   bfd_map_over_sections (core_bfd, add_to_thread_list,
 228                          bfd_get_section_by_name (core_bfd, ".reg"));
 229
 230   if (ontop)
 231     {
 232       /* Fetch all registers from core file.  */
 233       target_fetch_registers (-1);
 234
 235       /* Add symbols and section mappings for any shared libraries.  */
 236 #ifdef SOLIB_ADD
 237       catch_errors (solib_add_stub, &from_tty, (char *)0,
 238                     RETURN_MASK_ALL);
 239 #endif
 240
 241       /* Now, set up the frame cache, and print the top of stack.  */
 242       flush_cached_frames ();
 243       select_frame (get_current_frame (), 0);
 244       print_stack_frame (selected_frame, selected_frame_level, 1);
 245     }
 246   else
 247     {
 248       warning (
 249 "you won't be able to access this core file until you terminate\n\
 250 your %s; do ``info files''", target_longname);
 251     }
 252 }
 253
 254 static void
 255 core_detach (args, from_tty)
 256      char *args;
 257      int from_tty;
 258 {
 259   if (args)
 260     error ("Too many arguments");
 261   unpush_target (&core_ops);
 262   reinit_frame_cache ();
 263   if (from_tty)
 264     printf_filtered ("No core file now.\n");
 265 }
 266
 267 /* Get the registers out of a core file.  This is the machine-
 268    independent part.  Fetch_core_registers is the machine-dependent
 269    part, typically implemented in the xm-file for each architecture.  */
 270
 271 /* We just get all the registers, so we don't use regno.  */
 272
 273 /* ARGSUSED */
 274 static void
 275 get_core_registers (regno)
 276      int regno;
 277 {
 278   sec_ptr reg_sec;
 279   unsigned size;
 280   char *the_regs;
 281   char secname[10];
 282   enum bfd_flavour our_flavour = bfd_get_flavour (core_bfd);
 283   struct core_fns *cf = NULL;
 284
 285   if (core_file_fns == NULL)
 286     {
 287       fprintf_filtered (gdb_stderr,
 288                         "Can't fetch registers from this type of core file\n");
 289       return;
 290     }
 291
 292   /* Thread support.  If inferior_pid is non-zero, then we have found a core
 293      file with threads (or multiple processes).  In that case, we need to
 294      use the appropriate register section, else we just use `.reg'. */
 295
 296   /* XXX - same thing needs to be done for floating-point (.reg2) sections. */
 297
 298   if (inferior_pid)
 299     sprintf (secname, ".reg/%d", inferior_pid);
 300   else
 301     strcpy (secname, ".reg");
 302
 303   reg_sec = bfd_get_section_by_name (core_bfd, secname);
 304   if (!reg_sec)
 305     goto cant;
 306   size = bfd_section_size (core_bfd, reg_sec);
 307   the_regs = alloca (size);
 308   /* Look for the core functions that match this flavor.  Default to the
 309      first one if nothing matches. */
 310   for (cf = core_file_fns; cf != NULL; cf = cf -> next)
 311     {
 312       if (our_flavour == cf -> core_flavour)
 313         {
 314           break;
 315         }
 316     }
 317   if (cf == NULL)
 318     {
 319       cf = core_file_fns;
 320     }
 321   if (cf != NULL &&
 322       bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0, size) &&
 323       cf -> core_read_registers != NULL)
 324     {
 325       (cf -> core_read_registers (the_regs, size, 0,
 326                                   (unsigned) bfd_section_vma (abfd,reg_sec)));
 327     }
 328   else
 329     {
 330 cant:
 331       fprintf_filtered (gdb_stderr,
 332                         "Couldn't fetch registers from core file: %s\n",
 333                         bfd_errmsg (bfd_get_error ()));
 334     }
 335
 336   /* Now do it again for the float registers, if they exist.  */
 337   reg_sec = bfd_get_section_by_name (core_bfd, ".reg2");
 338   if (reg_sec)
 339     {
 340       size = bfd_section_size (core_bfd, reg_sec);
 341       the_regs = alloca (size);
 342       if (cf != NULL &&
 343           bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0, size) &&
 344           cf -> core_read_registers != NULL)
 345         {
 346           (cf -> core_read_registers (the_regs, size, 2,
 347                                       (unsigned) bfd_section_vma (abfd,reg_sec)));
 348         }
 349       else
 350         {
 351           fprintf_filtered (gdb_stderr,
 352                             "Couldn't fetch register set 2 from core file: %s\n",
 353                             bfd_errmsg (bfd_get_error ()));
 354         }
 355     }
 356   registers_fetched ();
 357 }
 358
 359 static void
 360 core_files_info (t)
 361   struct target_ops *t;
 362 {
 363   print_section_info (t, core_bfd);
 364 }
 365 \f
 366 /* If mourn is being called in all the right places, this could be say
 367    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 368
 369 static int
 370 ignore (addr, contents)
 371      CORE_ADDR addr;
 372      char *contents;
 373 {
 374   return 0;
 375 }
 376
 377 struct target_ops core_ops = {
 378   "core",                       /* to_shortname */
 379   "Local core dump file",       /* to_longname */
 380   "Use a core file as a target.  Specify the filename of the core file.", /* to_doc */
 381   core_open,                    /* to_open */
 382   core_close,                   /* to_close */
 383   find_default_attach,          /* to_attach */
 384   core_detach,                  /* to_detach */
 385   0,                            /* to_resume */
 386   0,                            /* to_wait */
 387   get_core_registers,           /* to_fetch_registers */
 388   0,                            /* to_store_registers */
 389   0,                            /* to_prepare_to_store */
 390   xfer_memory,                  /* to_xfer_memory */
 391   core_files_info,              /* to_files_info */
 392   ignore,                       /* to_insert_breakpoint */
 393   ignore,                       /* to_remove_breakpoint */
 394   0,                            /* to_terminal_init */
 395   0,                            /* to_terminal_inferior */
 396   0,                            /* to_terminal_ours_for_output */
 397   0,                            /* to_terminal_ours */
 398   0,                            /* to_terminal_info */
 399   0,                            /* to_kill */
 400   0,                            /* to_load */
 401   0,                            /* to_lookup_symbol */
 402   find_default_create_inferior, /* to_create_inferior */
 403   0,                            /* to_mourn_inferior */
 404   0,                            /* to_can_run */
 405   0,                            /* to_notice_signals */
 406   0,                            /* to_thread_alive */
 407   0,                            /* to_stop */
 408   core_stratum,                 /* to_stratum */
 409   0,                            /* to_next */
 410   0,                            /* to_has_all_memory */
 411   1,                            /* to_has_memory */
 412   1,                            /* to_has_stack */
 413   1,                            /* to_has_registers */
 414   0,                            /* to_has_execution */
 415   0,                            /* to_sections */
 416   0,                            /* to_sections_end */
 417   OPS_MAGIC,                    /* to_magic */
 418 };
 419
 420 void
 421 _initialize_corelow()
 422 {
 423   add_target (&core_ops);
 424 }