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