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