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    1998, 1999, 2000, 2001
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "gdb_string.h"
  25 #include <errno.h>
  26 #include <signal.h>
  27 #include <fcntl.h>
  28 #ifdef HAVE_SYS_FILE_H
  29 #include <sys/file.h>           /* needed for F_OK and friends */
  30 #endif
  31 #include "frame.h"              /* required by inferior.h */
  32 #include "inferior.h"
  33 #include "symtab.h"
  34 #include "command.h"
  35 #include "bfd.h"
  36 #include "target.h"
  37 #include "gdbcore.h"
  38 #include "gdbthread.h"
  39 #include "regcache.h"
  40 #include "symfile.h"
  41 #include <readline/readline.h>
  42
  43 #ifndef O_BINARY
  44 #define O_BINARY 0
  45 #endif
  46
  47 /* List of all available core_fns.  On gdb startup, each core file register
  48    reader calls add_core_fns() to register information on each core format it
  49    is prepared to read. */
  50
  51 static struct core_fns *core_file_fns = NULL;
  52
  53 /* The core_fns for a core file handler that is prepared to read the core
  54    file currently open on core_bfd. */
  55
  56 static struct core_fns *core_vec = NULL;
  57
  58 static void core_files_info (struct target_ops *);
  59
  60 #ifdef SOLIB_ADD
  61 static int solib_add_stub (void *);
  62 #endif
  63
  64 static struct core_fns *sniff_core_bfd (bfd *);
  65
  66 static int gdb_check_format (bfd *);
  67
  68 static void core_open (char *, int);
  69
  70 static void core_detach (char *, int);
  71
  72 static void core_close (int);
  73
  74 static void core_close_cleanup (void *ignore);
  75
  76 static void get_core_registers (int);
  77
  78 static void add_to_thread_list (bfd *, asection *, void *);
  79
  80 static int ignore (CORE_ADDR, char *);
  81
  82 static int core_file_thread_alive (ptid_t tid);
  83
  84 static void init_core_ops (void);
  85
  86 void _initialize_corelow (void);
  87
  88 struct target_ops core_ops;
  89
  90 /* Link a new core_fns into the global core_file_fns list.  Called on gdb
  91    startup by the _initialize routine in each core file register reader, to
  92    register information about each format the the reader is prepared to
  93    handle. */
  94
  95 void
  96 add_core_fns (struct core_fns *cf)
  97 {
  98   cf->next = core_file_fns;
  99   core_file_fns = cf;
 100 }
 101
 102 /* The default function that core file handlers can use to examine a
 103    core file BFD and decide whether or not to accept the job of
 104    reading the core file. */
 105
 106 int
 107 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
 108 {
 109   int result;
 110
 111   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
 112   return (result);
 113 }
 114
 115 /* Walk through the list of core functions to find a set that can
 116    handle the core file open on ABFD.  Default to the first one in the
 117    list if nothing matches.  Returns pointer to set that is
 118    selected. */
 119
 120 static struct core_fns *
 121 sniff_core_bfd (bfd *abfd)
 122 {
 123   struct core_fns *cf;
 124   struct core_fns *yummy = NULL;
 125   int matches = 0;;
 126
 127   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 128     {
 129       if (cf->core_sniffer (cf, abfd))
 130         {
 131           yummy = cf;
 132           matches++;
 133         }
 134     }
 135   if (matches > 1)
 136     {
 137       warning ("\"%s\": ambiguous core format, %d handlers match",
 138                bfd_get_filename (abfd), matches);
 139     }
 140   else if (matches == 0)
 141     {
 142       warning ("\"%s\": no core file handler recognizes format, using default",
 143                bfd_get_filename (abfd));
 144     }
 145   if (yummy == NULL)
 146     {
 147       yummy = core_file_fns;
 148     }
 149   return (yummy);
 150 }
 151
 152 /* The default is to reject every core file format we see.  Either
 153    BFD has to recognize it, or we have to provide a function in the
 154    core file handler that recognizes it. */
 155
 156 int
 157 default_check_format (bfd *abfd)
 158 {
 159   return (0);
 160 }
 161
 162 /* Attempt to recognize core file formats that BFD rejects. */
 163
 164 static int
 165 gdb_check_format (bfd *abfd)
 166 {
 167   struct core_fns *cf;
 168
 169   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 170     {
 171       if (cf->check_format (abfd))
 172         {
 173           return (1);
 174         }
 175     }
 176   return (0);
 177 }
 178
 179 /* Discard all vestiges of any previous core file and mark data and stack
 180    spaces as empty.  */
 181
 182 static void
 183 core_close (int quitting)
 184 {
 185   char *name;
 186
 187   if (core_bfd)
 188     {
 189       inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff */
 190
 191       /* Clear out solib state while the bfd is still open. See
 192          comments in clear_solib in solib.c. */
 193 #ifdef CLEAR_SOLIB
 194       CLEAR_SOLIB ();
 195 #endif
 196
 197       name = bfd_get_filename (core_bfd);
 198       if (!bfd_close (core_bfd))
 199         warning ("cannot close \"%s\": %s",
 200                  name, bfd_errmsg (bfd_get_error ()));
 201       xfree (name);
 202       core_bfd = NULL;
 203       if (core_ops.to_sections)
 204         {
 205           xfree (core_ops.to_sections);
 206           core_ops.to_sections = NULL;
 207           core_ops.to_sections_end = NULL;
 208         }
 209     }
 210   core_vec = NULL;
 211 }
 212
 213 static void
 214 core_close_cleanup (void *ignore)
 215 {
 216   core_close (0/*ignored*/);
 217 }
 218
 219 #ifdef SOLIB_ADD
 220 /* Stub function for catch_errors around shared library hacking.  FROM_TTYP
 221    is really an int * which points to from_tty.  */
 222
 223 static int
 224 solib_add_stub (void *from_ttyp)
 225 {
 226   SOLIB_ADD (NULL, *(int *) from_ttyp, &current_target, auto_solib_add);
 227   re_enable_breakpoints_in_shlibs ();
 228   return 0;
 229 }
 230 #endif /* SOLIB_ADD */
 231
 232 /* Look for sections whose names start with `.reg/' so that we can extract the
 233    list of threads in a core file.  */
 234
 235 static void
 236 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
 237 {
 238   int thread_id;
 239   asection *reg_sect = (asection *) reg_sect_arg;
 240
 241   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 242     return;
 243
 244   thread_id = atoi (bfd_section_name (abfd, asect) + 5);
 245
 246   add_thread (pid_to_ptid (thread_id));
 247
 248 /* Warning, Will Robinson, looking at BFD private data! */
 249
 250   if (reg_sect != NULL
 251       && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
 252     inferior_ptid = pid_to_ptid (thread_id);    /* Yes, make it current */
 253 }
 254
 255 /* This routine opens and sets up the core file bfd.  */
 256
 257 static void
 258 core_open (char *filename, int from_tty)
 259 {
 260   const char *p;
 261   int siggy;
 262   struct cleanup *old_chain;
 263   char *temp;
 264   bfd *temp_bfd;
 265   int ontop;
 266   int scratch_chan;
 267
 268   target_preopen (from_tty);
 269   if (!filename)
 270     {
 271       error (core_bfd ?
 272              "No core file specified.  (Use `detach' to stop debugging a core file.)"
 273              : "No core file specified.");
 274     }
 275
 276   filename = tilde_expand (filename);
 277   if (filename[0] != '/')
 278     {
 279       temp = concat (current_directory, "/", filename, NULL);
 280       xfree (filename);
 281       filename = temp;
 282     }
 283
 284   old_chain = make_cleanup (xfree, filename);
 285
 286   scratch_chan = open (filename, O_BINARY | ( write_files ? O_RDWR : O_RDONLY ), 0);
 287   if (scratch_chan < 0)
 288     perror_with_name (filename);
 289
 290   temp_bfd = bfd_fdopenr (filename, gnutarget, scratch_chan);
 291   if (temp_bfd == NULL)
 292     perror_with_name (filename);
 293
 294   if (!bfd_check_format (temp_bfd, bfd_core) &&
 295       !gdb_check_format (temp_bfd))
 296     {
 297       /* Do it after the err msg */
 298       /* FIXME: should be checking for errors from bfd_close (for one thing,
 299          on error it does not free all the storage associated with the
 300          bfd).  */
 301       make_cleanup_bfd_close (temp_bfd);
 302       error ("\"%s\" is not a core dump: %s",
 303              filename, bfd_errmsg (bfd_get_error ()));
 304     }
 305
 306   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 307
 308   discard_cleanups (old_chain); /* Don't free filename any more */
 309   unpush_target (&core_ops);
 310   core_bfd = temp_bfd;
 311   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 312
 313   /* Find a suitable core file handler to munch on core_bfd */
 314   core_vec = sniff_core_bfd (core_bfd);
 315
 316   validate_files ();
 317
 318   /* Find the data section */
 319   if (build_section_table (core_bfd, &core_ops.to_sections,
 320                            &core_ops.to_sections_end))
 321     error ("\"%s\": Can't find sections: %s",
 322            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 323
 324   /* If we have no exec file, try to set the architecture from the
 325      core file.  We don't do this unconditionally since an exec file
 326      typically contains more information that helps us determine the
 327      architecture than a core file.  */
 328   if (!exec_bfd)
 329     set_gdbarch_from_file (core_bfd);
 330
 331   ontop = !push_target (&core_ops);
 332   discard_cleanups (old_chain);
 333
 334   p = bfd_core_file_failing_command (core_bfd);
 335   if (p)
 336     printf_filtered ("Core was generated by `%s'.\n", p);
 337
 338   siggy = bfd_core_file_failing_signal (core_bfd);
 339   if (siggy > 0)
 340     /* NOTE: target_signal_from_host() converts a target signal value
 341        into gdb's internal signal value.  Unfortunately gdb's internal
 342        value is called ``target_signal'' and this function got the
 343        name ..._from_host(). */
 344     printf_filtered ("Program terminated with signal %d, %s.\n", siggy,
 345                      target_signal_to_string (target_signal_from_host (siggy)));
 346
 347   /* Build up thread list from BFD sections. */
 348
 349   init_thread_list ();
 350   bfd_map_over_sections (core_bfd, add_to_thread_list,
 351                          bfd_get_section_by_name (core_bfd, ".reg"));
 352
 353   if (ontop)
 354     {
 355       /* Fetch all registers from core file.  */
 356       target_fetch_registers (-1);
 357
 358       /* Add symbols and section mappings for any shared libraries.  */
 359 #ifdef SOLIB_ADD
 360       catch_errors (solib_add_stub, &from_tty, (char *) 0,
 361                     RETURN_MASK_ALL);
 362 #endif
 363
 364       /* Now, set up the frame cache, and print the top of stack.  */
 365       flush_cached_frames ();
 366       select_frame (get_current_frame ());
 367       print_stack_frame (deprecated_selected_frame,
 368                          frame_relative_level (deprecated_selected_frame), 1);
 369     }
 370   else
 371     {
 372       warning (
 373                 "you won't be able to access this core file until you terminate\n\
 374 your %s; do ``info files''", target_longname);
 375     }
 376 }
 377
 378 static void
 379 core_detach (char *args, int from_tty)
 380 {
 381   if (args)
 382     error ("Too many arguments");
 383   unpush_target (&core_ops);
 384   reinit_frame_cache ();
 385   if (from_tty)
 386     printf_filtered ("No core file now.\n");
 387 }
 388
 389
 390 /* Try to retrieve registers from a section in core_bfd, and supply
 391    them to core_vec->core_read_registers, as the register set numbered
 392    WHICH.
 393
 394    If inferior_ptid is zero, do the single-threaded thing: look for a
 395    section named NAME.  If inferior_ptid is non-zero, do the
 396    multi-threaded thing: look for a section named "NAME/PID", where
 397    PID is the shortest ASCII decimal representation of inferior_ptid.
 398
 399    HUMAN_NAME is a human-readable name for the kind of registers the
 400    NAME section contains, for use in error messages.
 401
 402    If REQUIRED is non-zero, print an error if the core file doesn't
 403    have a section by the appropriate name.  Otherwise, just do nothing.  */
 404
 405 static void
 406 get_core_register_section (char *name,
 407                            int which,
 408                            char *human_name,
 409                            int required)
 410 {
 411   char section_name[100];
 412   sec_ptr section;
 413   bfd_size_type size;
 414   char *contents;
 415
 416   if (PIDGET (inferior_ptid))
 417     sprintf (section_name, "%s/%d", name, PIDGET (inferior_ptid));
 418   else
 419     strcpy (section_name, name);
 420
 421   section = bfd_get_section_by_name (core_bfd, section_name);
 422   if (! section)
 423     {
 424       if (required)
 425         warning ("Couldn't find %s registers in core file.\n", human_name);
 426       return;
 427     }
 428
 429   size = bfd_section_size (core_bfd, section);
 430   contents = alloca (size);
 431   if (! bfd_get_section_contents (core_bfd, section, contents,
 432                                   (file_ptr) 0, size))
 433     {
 434       warning ("Couldn't read %s registers from `%s' section in core file.\n",
 435                human_name, name);
 436       return;
 437     }
 438
 439   core_vec->core_read_registers (contents, size, which,
 440                                  ((CORE_ADDR)
 441                                   bfd_section_vma (core_bfd, section)));
 442 }
 443
 444
 445 /* Get the registers out of a core file.  This is the machine-
 446    independent part.  Fetch_core_registers is the machine-dependent
 447    part, typically implemented in the xm-file for each architecture.  */
 448
 449 /* We just get all the registers, so we don't use regno.  */
 450
 451 static void
 452 get_core_registers (int regno)
 453 {
 454   int status;
 455
 456   if (core_vec == NULL
 457       || core_vec->core_read_registers == NULL)
 458     {
 459       fprintf_filtered (gdb_stderr,
 460                      "Can't fetch registers from this type of core file\n");
 461       return;
 462     }
 463
 464   get_core_register_section (".reg", 0, "general-purpose", 1);
 465   get_core_register_section (".reg2", 2, "floating-point", 0);
 466   get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
 467
 468   deprecated_registers_fetched ();
 469 }
 470
 471 static void
 472 core_files_info (struct target_ops *t)
 473 {
 474   print_section_info (t, core_bfd);
 475 }
 476 \f
 477 /* If mourn is being called in all the right places, this could be say
 478    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 479
 480 static int
 481 ignore (CORE_ADDR addr, char *contents)
 482 {
 483   return 0;
 484 }
 485
 486
 487 /* Okay, let's be honest: threads gleaned from a core file aren't
 488    exactly lively, are they?  On the other hand, if we don't claim
 489    that each & every one is alive, then we don't get any of them
 490    to appear in an "info thread" command, which is quite a useful
 491    behaviour.
 492  */
 493 static int
 494 core_file_thread_alive (ptid_t tid)
 495 {
 496   return 1;
 497 }
 498
 499 /* Fill in core_ops with its defined operations and properties.  */
 500
 501 static void
 502 init_core_ops (void)
 503 {
 504   core_ops.to_shortname = "core";
 505   core_ops.to_longname = "Local core dump file";
 506   core_ops.to_doc =
 507     "Use a core file as a target.  Specify the filename of the core file.";
 508   core_ops.to_open = core_open;
 509   core_ops.to_close = core_close;
 510   core_ops.to_attach = find_default_attach;
 511   core_ops.to_detach = core_detach;
 512   core_ops.to_fetch_registers = get_core_registers;
 513   core_ops.to_xfer_memory = xfer_memory;
 514   core_ops.to_files_info = core_files_info;
 515   core_ops.to_insert_breakpoint = ignore;
 516   core_ops.to_remove_breakpoint = ignore;
 517   core_ops.to_create_inferior = find_default_create_inferior;
 518   core_ops.to_thread_alive = core_file_thread_alive;
 519   core_ops.to_stratum = core_stratum;
 520   core_ops.to_has_memory = 1;
 521   core_ops.to_has_stack = 1;
 522   core_ops.to_has_registers = 1;
 523   core_ops.to_magic = OPS_MAGIC;
 524 }
 525
 526 /* non-zero if we should not do the add_target call in
 527    _initialize_corelow; not initialized (i.e., bss) so that
 528    the target can initialize it (i.e., data) if appropriate.
 529    This needs to be set at compile time because we don't know
 530    for sure whether the target's initialize routine is called
 531    before us or after us. */
 532 int coreops_suppress_target;
 533
 534 void
 535 _initialize_corelow (void)
 536 {
 537   init_core_ops ();
 538
 539   if (!coreops_suppress_target)
 540     add_target (&core_ops);
 541 }