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   ontop = !push_target (&core_ops);
 322   discard_cleanups (old_chain);
 323
 324   p = bfd_core_file_failing_command (core_bfd);
 325   if (p)
 326     printf_filtered ("Core was generated by `%s'.\n", p);
 327
 328   siggy = bfd_core_file_failing_signal (core_bfd);
 329   if (siggy > 0)
 330     printf_filtered ("Program terminated with signal %d, %s.\n", siggy,
 331                      safe_strsignal (siggy));
 332
 333   /* Build up thread list from BFD sections. */
 334
 335   init_thread_list ();
 336   bfd_map_over_sections (core_bfd, add_to_thread_list,
 337                          bfd_get_section_by_name (core_bfd, ".reg"));
 338
 339   if (ontop)
 340     {
 341       /* Fetch all registers from core file.  */
 342       target_fetch_registers (-1);
 343
 344       /* Add symbols and section mappings for any shared libraries.  */
 345 #ifdef SOLIB_ADD
 346       catch_errors (solib_add_stub, &from_tty, (char *) 0,
 347                     RETURN_MASK_ALL);
 348 #endif
 349
 350       /* Now, set up the frame cache, and print the top of stack.  */
 351       flush_cached_frames ();
 352       select_frame (get_current_frame (), 0);
 353       print_stack_frame (selected_frame, selected_frame_level, 1);
 354     }
 355   else
 356     {
 357       warning (
 358                 "you won't be able to access this core file until you terminate\n\
 359 your %s; do ``info files''", target_longname);
 360     }
 361 }
 362
 363 static void
 364 core_detach (args, from_tty)
 365      char *args;
 366      int from_tty;
 367 {
 368   if (args)
 369     error ("Too many arguments");
 370   unpush_target (&core_ops);
 371   reinit_frame_cache ();
 372   if (from_tty)
 373     printf_filtered ("No core file now.\n");
 374 }
 375
 376
 377 /* Try to retrieve registers from a section in core_bfd, and supply
 378    them to core_vec->core_read_registers, as the register set numbered
 379    WHICH.
 380
 381    If inferior_pid is zero, do the single-threaded thing: look for a
 382    section named NAME.  If inferior_pid is non-zero, do the
 383    multi-threaded thing: look for a section named "NAME/PID", where
 384    PID is the shortest ASCII decimal representation of inferior_pid.
 385
 386    HUMAN_NAME is a human-readable name for the kind of registers the
 387    NAME section contains, for use in error messages.
 388
 389    If REQUIRED is non-zero, print an error if the core file doesn't
 390    have a section by the appropriate name.  Otherwise, just do nothing.  */
 391
 392 static void
 393 get_core_register_section (char *name,
 394                            int which,
 395                            char *human_name,
 396                            int required)
 397 {
 398   char section_name[100];
 399   sec_ptr section;
 400   bfd_size_type size;
 401   char *contents;
 402
 403   if (inferior_pid)
 404     sprintf (section_name, "%s/%d", name, inferior_pid);
 405   else
 406     strcpy (section_name, name);
 407
 408   section = bfd_get_section_by_name (core_bfd, section_name);
 409   if (! section)
 410     {
 411       if (required)
 412         warning ("Couldn't find %s registers in core file.\n", human_name);
 413       return;
 414     }
 415
 416   size = bfd_section_size (core_bfd, section);
 417   contents = alloca (size);
 418   if (! bfd_get_section_contents (core_bfd, section, contents,
 419                                   (file_ptr) 0, size))
 420     {
 421       warning ("Couldn't read %s registers from `%s' section in core file.\n",
 422                human_name, name);
 423       return;
 424     }
 425
 426   core_vec->core_read_registers (contents, size, which,
 427                                  ((CORE_ADDR)
 428                                   bfd_section_vma (core_bfd, section)));
 429 }
 430
 431
 432 /* Get the registers out of a core file.  This is the machine-
 433    independent part.  Fetch_core_registers is the machine-dependent
 434    part, typically implemented in the xm-file for each architecture.  */
 435
 436 /* We just get all the registers, so we don't use regno.  */
 437
 438 /* ARGSUSED */
 439 static void
 440 get_core_registers (regno)
 441      int regno;
 442 {
 443   int status;
 444
 445   if (core_vec == NULL
 446       || core_vec->core_read_registers == NULL)
 447     {
 448       fprintf_filtered (gdb_stderr,
 449                      "Can't fetch registers from this type of core file\n");
 450       return;
 451     }
 452
 453   get_core_register_section (".reg", 0, "general-purpose", 1);
 454   get_core_register_section (".reg2", 2, "floating-point", 0);
 455   get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
 456
 457   registers_fetched ();
 458 }
 459
 460 static char *
 461 core_file_to_sym_file (core)
 462      char *core;
 463 {
 464   CONST char *failing_command;
 465   char *p;
 466   char *temp;
 467   bfd *temp_bfd;
 468   int scratch_chan;
 469
 470   if (!core)
 471     error ("No core file specified.");
 472
 473   core = tilde_expand (core);
 474   if (core[0] != '/')
 475     {
 476       temp = concat (current_directory, "/", core, NULL);
 477       core = temp;
 478     }
 479
 480   scratch_chan = open (core, write_files ? O_RDWR : O_RDONLY, 0);
 481   if (scratch_chan < 0)
 482     perror_with_name (core);
 483
 484   temp_bfd = bfd_fdopenr (core, gnutarget, scratch_chan);
 485   if (temp_bfd == NULL)
 486     perror_with_name (core);
 487
 488   if (!bfd_check_format (temp_bfd, bfd_core))
 489     {
 490       /* Do it after the err msg */
 491       /* FIXME: should be checking for errors from bfd_close (for one thing,
 492          on error it does not free all the storage associated with the
 493          bfd).  */
 494       make_cleanup ((make_cleanup_func) bfd_close, temp_bfd);
 495       error ("\"%s\" is not a core dump: %s",
 496              core, bfd_errmsg (bfd_get_error ()));
 497     }
 498
 499   /* Find the data section */
 500   if (build_section_table (temp_bfd, &core_ops.to_sections,
 501                            &core_ops.to_sections_end))
 502     error ("\"%s\": Can't find sections: %s",
 503            bfd_get_filename (temp_bfd), bfd_errmsg (bfd_get_error ()));
 504
 505   failing_command = bfd_core_file_failing_command (temp_bfd);
 506
 507   bfd_close (temp_bfd);
 508
 509   /* If we found a filename, remember that it is probably saved
 510      relative to the executable that created it.  If working directory
 511      isn't there now, we may not be able to find the executable.  Rather
 512      than trying to be sauve about finding it, just check if the file
 513      exists where we are now.  If not, then punt and tell our client
 514      we couldn't find the sym file.
 515    */
 516   p = (char *) failing_command;
 517   if ((p != NULL) && (access (p, F_OK) != 0))
 518     p = NULL;
 519
 520   return p;
 521 }
 522
 523 static void
 524 core_files_info (t)
 525      struct target_ops *t;
 526 {
 527   print_section_info (t, core_bfd);
 528 }
 529 \f
 530 /* If mourn is being called in all the right places, this could be say
 531    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 532
 533 static int
 534 ignore (addr, contents)
 535      CORE_ADDR addr;
 536      char *contents;
 537 {
 538   return 0;
 539 }
 540
 541
 542 /* Okay, let's be honest: threads gleaned from a core file aren't
 543    exactly lively, are they?  On the other hand, if we don't claim
 544    that each & every one is alive, then we don't get any of them
 545    to appear in an "info thread" command, which is quite a useful
 546    behaviour.
 547  */
 548 static int
 549 core_file_thread_alive (tid)
 550      int tid;
 551 {
 552   return 1;
 553 }
 554
 555 /* Fill in core_ops with its defined operations and properties.  */
 556
 557 static void
 558 init_core_ops ()
 559 {
 560   core_ops.to_shortname = "core";
 561   core_ops.to_longname = "Local core dump file";
 562   core_ops.to_doc =
 563     "Use a core file as a target.  Specify the filename of the core file.";
 564   core_ops.to_open = core_open;
 565   core_ops.to_close = core_close;
 566   core_ops.to_attach = find_default_attach;
 567   core_ops.to_require_attach = find_default_require_attach;
 568   core_ops.to_detach = core_detach;
 569   core_ops.to_require_detach = find_default_require_detach;
 570   core_ops.to_fetch_registers = get_core_registers;
 571   core_ops.to_xfer_memory = xfer_memory;
 572   core_ops.to_files_info = core_files_info;
 573   core_ops.to_insert_breakpoint = ignore;
 574   core_ops.to_remove_breakpoint = ignore;
 575   core_ops.to_create_inferior = find_default_create_inferior;
 576   core_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
 577   core_ops.to_thread_alive = core_file_thread_alive;
 578   core_ops.to_core_file_to_sym_file = core_file_to_sym_file;
 579   core_ops.to_stratum = core_stratum;
 580   core_ops.to_has_memory = 1;
 581   core_ops.to_has_stack = 1;
 582   core_ops.to_has_registers = 1;
 583   core_ops.to_magic = OPS_MAGIC;
 584 }
 585
 586 /* non-zero if we should not do the add_target call in
 587    _initialize_corelow; not initialized (i.e., bss) so that
 588    the target can initialize it (i.e., data) if appropriate.
 589    This needs to be set at compile time because we don't know
 590    for sure whether the target's initialize routine is called
 591    before us or after us. */
 592 int coreops_suppress_target;
 593
 594 void
 595 _initialize_corelow ()
 596 {
 597   init_core_ops ();
 598
 599   if (!coreops_suppress_target)
 600     add_target (&core_ops);
 601 }