gdb/corelow.c

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