gdb/corelow.c

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