gdb/corelow.c

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