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