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