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