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