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