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 /* ARGSUSED */
 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 /* ARGSUSED */
 453 static void
 454 get_core_registers (int regno)
 455 {
 456   int status;
 457
 458   if (core_vec == NULL
 459       || core_vec->core_read_registers == NULL)
 460     {
 461       fprintf_filtered (gdb_stderr,
 462                      "Can't fetch registers from this type of core file\n");
 463       return;
 464     }
 465
 466   get_core_register_section (".reg", 0, "general-purpose", 1);
 467   get_core_register_section (".reg2", 2, "floating-point", 0);
 468   get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
 469
 470   deprecated_registers_fetched ();
 471 }
 472
 473 static void
 474 core_files_info (struct target_ops *t)
 475 {
 476   print_section_info (t, core_bfd);
 477 }
 478 \f
 479 /* If mourn is being called in all the right places, this could be say
 480    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 481
 482 static int
 483 ignore (CORE_ADDR addr, char *contents)
 484 {
 485   return 0;
 486 }
 487
 488
 489 /* Okay, let's be honest: threads gleaned from a core file aren't
 490    exactly lively, are they?  On the other hand, if we don't claim
 491    that each & every one is alive, then we don't get any of them
 492    to appear in an "info thread" command, which is quite a useful
 493    behaviour.
 494  */
 495 static int
 496 core_file_thread_alive (ptid_t tid)
 497 {
 498   return 1;
 499 }
 500
 501 /* Fill in core_ops with its defined operations and properties.  */
 502
 503 static void
 504 init_core_ops (void)
 505 {
 506   core_ops.to_shortname = "core";
 507   core_ops.to_longname = "Local core dump file";
 508   core_ops.to_doc =
 509     "Use a core file as a target.  Specify the filename of the core file.";
 510   core_ops.to_open = core_open;
 511   core_ops.to_close = core_close;
 512   core_ops.to_attach = find_default_attach;
 513   core_ops.to_detach = core_detach;
 514   core_ops.to_fetch_registers = get_core_registers;
 515   core_ops.to_xfer_memory = xfer_memory;
 516   core_ops.to_files_info = core_files_info;
 517   core_ops.to_insert_breakpoint = ignore;
 518   core_ops.to_remove_breakpoint = ignore;
 519   core_ops.to_create_inferior = find_default_create_inferior;
 520   core_ops.to_thread_alive = core_file_thread_alive;
 521   core_ops.to_stratum = core_stratum;
 522   core_ops.to_has_memory = 1;
 523   core_ops.to_has_stack = 1;
 524   core_ops.to_has_registers = 1;
 525   core_ops.to_magic = OPS_MAGIC;
 526 }
 527
 528 /* non-zero if we should not do the add_target call in
 529    _initialize_corelow; not initialized (i.e., bss) so that
 530    the target can initialize it (i.e., data) if appropriate.
 531    This needs to be set at compile time because we don't know
 532    for sure whether the target's initialize routine is called
 533    before us or after us. */
 534 int coreops_suppress_target;
 535
 536 void
 537 _initialize_corelow (void)
 538 {
 539   init_core_ops ();
 540
 541   if (!coreops_suppress_target)
 542     add_target (&core_ops);
 543 }