gdb/corelow.c

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