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