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