gdb/corelow.c

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