gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "gdb_string.h"
  25 #include <errno.h>
  26 #include <signal.h>
  27 #include <fcntl.h>
  28 #ifdef HAVE_SYS_FILE_H
  29 #include <sys/file.h>           /* needed for F_OK and friends */
  30 #endif
  31 #include "frame.h"              /* required by inferior.h */
  32 #include "inferior.h"
  33 #include "symtab.h"
  34 #include "command.h"
  35 #include "bfd.h"
  36 #include "target.h"
  37 #include "gdbcore.h"
  38 #include "gdbthread.h"
  39 #include "regcache.h"
  40
  41 #ifndef O_BINARY
  42 #define O_BINARY 0
  43 #endif
  44
  45 /* List of all available core_fns.  On gdb startup, each core file register
  46    reader calls add_core_fns() to register information on each core format it
  47    is prepared to read. */
  48
  49 static struct core_fns *core_file_fns = NULL;
  50
  51 /* The core_fns for a core file handler that is prepared to read the core
  52    file currently open on core_bfd. */
  53
  54 static struct core_fns *core_vec = NULL;
  55
  56 static void core_files_info (struct target_ops *);
  57
  58 #ifdef SOLIB_ADD
  59 static int solib_add_stub (PTR);
  60 #endif
  61
  62 static struct core_fns *sniff_core_bfd (bfd *);
  63
  64 static boolean gdb_check_format (bfd *);
  65
  66 static void core_open (char *, int);
  67
  68 static void core_detach (char *, int);
  69
  70 static void core_close (int);
  71
  72 static void core_close_cleanup (void *ignore);
  73
  74 static void get_core_registers (int);
  75
  76 static void add_to_thread_list (bfd *, asection *, PTR);
  77
  78 static int ignore (CORE_ADDR, char *);
  79
  80 static char *core_file_to_sym_file (char *);
  81
  82 static int core_file_thread_alive (int tid);
  83
  84 static void init_core_ops (void);
  85
  86 void _initialize_corelow (void);
  87
  88 struct target_ops core_ops;
  89
  90 /* Link a new core_fns into the global core_file_fns list.  Called on gdb
  91    startup by the _initialize routine in each core file register reader, to
  92    register information about each format the the reader is prepared to
  93    handle. */
  94
  95 void
  96 add_core_fns (struct core_fns *cf)
  97 {
  98   cf->next = core_file_fns;
  99   core_file_fns = cf;
 100 }
 101
 102 /* The default function that core file handlers can use to examine a
 103    core file BFD and decide whether or not to accept the job of
 104    reading the core file. */
 105
 106 int
 107 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
 108 {
 109   int result;
 110
 111   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
 112   return (result);
 113 }
 114
 115 /* Walk through the list of core functions to find a set that can
 116    handle the core file open on ABFD.  Default to the first one in the
 117    list if nothing matches.  Returns pointer to set that is
 118    selected. */
 119
 120 static struct core_fns *
 121 sniff_core_bfd (bfd *abfd)
 122 {
 123   struct core_fns *cf;
 124   struct core_fns *yummy = NULL;
 125   int matches = 0;;
 126
 127   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 128     {
 129       if (cf->core_sniffer (cf, abfd))
 130         {
 131           yummy = cf;
 132           matches++;
 133         }
 134     }
 135   if (matches > 1)
 136     {
 137       warning ("\"%s\": ambiguous core format, %d handlers match",
 138                bfd_get_filename (abfd), matches);
 139     }
 140   else if (matches == 0)
 141     {
 142       warning ("\"%s\": no core file handler recognizes format, using default",
 143                bfd_get_filename (abfd));
 144     }
 145   if (yummy == NULL)
 146     {
 147       yummy = core_file_fns;
 148     }
 149   return (yummy);
 150 }
 151
 152 /* The default is to reject every core file format we see.  Either
 153    BFD has to recognize it, or we have to provide a function in the
 154    core file handler that recognizes it. */
 155
 156 int
 157 default_check_format (bfd *abfd)
 158 {
 159   return (0);
 160 }
 161
 162 /* Attempt to recognize core file formats that BFD rejects. */
 163
 164 static boolean
 165 gdb_check_format (bfd *abfd)
 166 {
 167   struct core_fns *cf;
 168
 169   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 170     {
 171       if (cf->check_format (abfd))
 172         {
 173           return (true);
 174         }
 175     }
 176   return (false);
 177 }
 178
 179 /* Discard all vestiges of any previous core file and mark data and stack
 180    spaces as empty.  */
 181
 182 /* ARGSUSED */
 183 static void
 184 core_close (int quitting)
 185 {
 186   char *name;
 187
 188   if (core_bfd)
 189     {
 190       inferior_pid = 0;         /* Avoid confusion from thread stuff */
 191
 192       /* Clear out solib state while the bfd is still open. See
 193          comments in clear_solib in solib.c. */
 194 #ifdef CLEAR_SOLIB
 195       CLEAR_SOLIB ();
 196 #endif
 197
 198       name = bfd_get_filename (core_bfd);
 199       if (!bfd_close (core_bfd))
 200         warning ("cannot close \"%s\": %s",
 201                  name, bfd_errmsg (bfd_get_error ()));
 202       xfree (name);
 203       core_bfd = NULL;
 204       if (core_ops.to_sections)
 205         {
 206           xfree (core_ops.to_sections);
 207           core_ops.to_sections = NULL;
 208           core_ops.to_sections_end = NULL;
 209         }
 210     }
 211   core_vec = NULL;
 212 }
 213
 214 static void
 215 core_close_cleanup (void *ignore)
 216 {
 217   core_close (0/*ignored*/);
 218 }
 219
 220 #ifdef SOLIB_ADD
 221 /* Stub function for catch_errors around shared library hacking.  FROM_TTYP
 222    is really an int * which points to from_tty.  */
 223
 224 static int
 225 solib_add_stub (PTR from_ttyp)
 226 {
 227   SOLIB_ADD (NULL, *(int *) from_ttyp, &current_target);
 228   re_enable_breakpoints_in_shlibs ();
 229   return 0;
 230 }
 231 #endif /* SOLIB_ADD */
 232
 233 /* Look for sections whose names start with `.reg/' so that we can extract the
 234    list of threads in a core file.  */
 235
 236 static void
 237 add_to_thread_list (bfd *abfd, asection *asect, PTR reg_sect_arg)
 238 {
 239   int thread_id;
 240   asection *reg_sect = (asection *) reg_sect_arg;
 241
 242   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 243     return;
 244
 245   thread_id = atoi (bfd_section_name (abfd, asect) + 5);
 246
 247   add_thread (thread_id);
 248
 249 /* Warning, Will Robinson, looking at BFD private data! */
 250
 251   if (reg_sect != NULL
 252       && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
 253     inferior_pid = thread_id;   /* Yes, make it current */
 254 }
 255
 256 /* This routine opens and sets up the core file bfd.  */
 257
 258 static void
 259 core_open (char *filename, int from_tty)
 260 {
 261   const char *p;
 262   int siggy;
 263   struct cleanup *old_chain;
 264   char *temp;
 265   bfd *temp_bfd;
 266   int ontop;
 267   int scratch_chan;
 268
 269   target_preopen (from_tty);
 270   if (!filename)
 271     {
 272       error (core_bfd ?
 273              "No core file specified.  (Use `detach' to stop debugging a core file.)"
 274              : "No core file specified.");
 275     }
 276
 277   filename = tilde_expand (filename);
 278   if (filename[0] != '/')
 279     {
 280       temp = concat (current_directory, "/", filename, NULL);
 281       xfree (filename);
 282       filename = temp;
 283     }
 284
 285   old_chain = make_cleanup (xfree, filename);
 286
 287   scratch_chan = open (filename, O_BINARY | ( write_files ? O_RDWR : O_RDONLY ), 0);
 288   if (scratch_chan < 0)
 289     perror_with_name (filename);
 290
 291   temp_bfd = bfd_fdopenr (filename, gnutarget, scratch_chan);
 292   if (temp_bfd == NULL)
 293     perror_with_name (filename);
 294
 295   if (!bfd_check_format (temp_bfd, bfd_core) &&
 296       !gdb_check_format (temp_bfd))
 297     {
 298       /* Do it after the err msg */
 299       /* FIXME: should be checking for errors from bfd_close (for one thing,
 300          on error it does not free all the storage associated with the
 301          bfd).  */
 302       make_cleanup_bfd_close (temp_bfd);
 303       error ("\"%s\" is not a core dump: %s",
 304              filename, bfd_errmsg (bfd_get_error ()));
 305     }
 306
 307   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 308
 309   discard_cleanups (old_chain); /* Don't free filename any more */
 310   unpush_target (&core_ops);
 311   core_bfd = temp_bfd;
 312   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 313
 314   /* Find a suitable core file handler to munch on core_bfd */
 315   core_vec = sniff_core_bfd (core_bfd);
 316
 317   validate_files ();
 318
 319   /* Find the data section */
 320   if (build_section_table (core_bfd, &core_ops.to_sections,
 321                            &core_ops.to_sections_end))
 322     error ("\"%s\": Can't find sections: %s",
 323            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 324
 325   set_gdbarch_from_file (core_bfd);
 326
 327   ontop = !push_target (&core_ops);
 328   discard_cleanups (old_chain);
 329
 330   p = bfd_core_file_failing_command (core_bfd);
 331   if (p)
 332     printf_filtered ("Core was generated by `%s'.\n", p);
 333
 334   siggy = bfd_core_file_failing_signal (core_bfd);
 335   if (siggy > 0)
 336     /* NOTE: target_signal_from_host() converts a target signal value
 337        into gdb's internal signal value.  Unfortunately gdb's internal
 338        value is called ``target_signal'' and this function got the
 339        name ..._from_host(). */
 340     printf_filtered ("Program terminated with signal %d, %s.\n", siggy,
 341                      target_signal_to_string (target_signal_from_host (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 (char *args, int from_tty)
 375 {
 376   if (args)
 377     error ("Too many arguments");
 378   unpush_target (&core_ops);
 379   reinit_frame_cache ();
 380   if (from_tty)
 381     printf_filtered ("No core file now.\n");
 382 }
 383
 384
 385 /* Try to retrieve registers from a section in core_bfd, and supply
 386    them to core_vec->core_read_registers, as the register set numbered
 387    WHICH.
 388
 389    If inferior_pid is zero, do the single-threaded thing: look for a
 390    section named NAME.  If inferior_pid is non-zero, do the
 391    multi-threaded thing: look for a section named "NAME/PID", where
 392    PID is the shortest ASCII decimal representation of inferior_pid.
 393
 394    HUMAN_NAME is a human-readable name for the kind of registers the
 395    NAME section contains, for use in error messages.
 396
 397    If REQUIRED is non-zero, print an error if the core file doesn't
 398    have a section by the appropriate name.  Otherwise, just do nothing.  */
 399
 400 static void
 401 get_core_register_section (char *name,
 402                            int which,
 403                            char *human_name,
 404                            int required)
 405 {
 406   char section_name[100];
 407   sec_ptr section;
 408   bfd_size_type size;
 409   char *contents;
 410
 411   if (inferior_pid)
 412     sprintf (section_name, "%s/%d", name, inferior_pid);
 413   else
 414     strcpy (section_name, name);
 415
 416   section = bfd_get_section_by_name (core_bfd, section_name);
 417   if (! section)
 418     {
 419       if (required)
 420         warning ("Couldn't find %s registers in core file.\n", human_name);
 421       return;
 422     }
 423
 424   size = bfd_section_size (core_bfd, section);
 425   contents = alloca (size);
 426   if (! bfd_get_section_contents (core_bfd, section, contents,
 427                                   (file_ptr) 0, size))
 428     {
 429       warning ("Couldn't read %s registers from `%s' section in core file.\n",
 430                human_name, name);
 431       return;
 432     }
 433
 434   core_vec->core_read_registers (contents, size, which,
 435                                  ((CORE_ADDR)
 436                                   bfd_section_vma (core_bfd, section)));
 437 }
 438
 439
 440 /* Get the registers out of a core file.  This is the machine-
 441    independent part.  Fetch_core_registers is the machine-dependent
 442    part, typically implemented in the xm-file for each architecture.  */
 443
 444 /* We just get all the registers, so we don't use regno.  */
 445
 446 /* ARGSUSED */
 447 static void
 448 get_core_registers (int regno)
 449 {
 450   int status;
 451
 452   if (core_vec == NULL
 453       || core_vec->core_read_registers == NULL)
 454     {
 455       fprintf_filtered (gdb_stderr,
 456                      "Can't fetch registers from this type of core file\n");
 457       return;
 458     }
 459
 460   get_core_register_section (".reg", 0, "general-purpose", 1);
 461   get_core_register_section (".reg2", 2, "floating-point", 0);
 462   get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
 463
 464   registers_fetched ();
 465 }
 466
 467 static char *
 468 core_file_to_sym_file (char *core)
 469 {
 470   CONST char *failing_command;
 471   char *p;
 472   char *temp;
 473   bfd *temp_bfd;
 474   int scratch_chan;
 475
 476   if (!core)
 477     error ("No core file specified.");
 478
 479   core = tilde_expand (core);
 480   if (core[0] != '/')
 481     {
 482       temp = concat (current_directory, "/", core, NULL);
 483       core = temp;
 484     }
 485
 486   scratch_chan = open (core, write_files ? O_RDWR : O_RDONLY, 0);
 487   if (scratch_chan < 0)
 488     perror_with_name (core);
 489
 490   temp_bfd = bfd_fdopenr (core, gnutarget, scratch_chan);
 491   if (temp_bfd == NULL)
 492     perror_with_name (core);
 493
 494   if (!bfd_check_format (temp_bfd, bfd_core))
 495     {
 496       /* Do it after the err msg */
 497       /* FIXME: should be checking for errors from bfd_close (for one thing,
 498          on error it does not free all the storage associated with the
 499          bfd).  */
 500       make_cleanup_bfd_close (temp_bfd);
 501       error ("\"%s\" is not a core dump: %s",
 502              core, bfd_errmsg (bfd_get_error ()));
 503     }
 504
 505   /* Find the data section */
 506   if (build_section_table (temp_bfd, &core_ops.to_sections,
 507                            &core_ops.to_sections_end))
 508     error ("\"%s\": Can't find sections: %s",
 509            bfd_get_filename (temp_bfd), bfd_errmsg (bfd_get_error ()));
 510
 511   failing_command = bfd_core_file_failing_command (temp_bfd);
 512
 513   bfd_close (temp_bfd);
 514
 515   /* If we found a filename, remember that it is probably saved
 516      relative to the executable that created it.  If working directory
 517      isn't there now, we may not be able to find the executable.  Rather
 518      than trying to be sauve about finding it, just check if the file
 519      exists where we are now.  If not, then punt and tell our client
 520      we couldn't find the sym file.
 521    */
 522   p = (char *) failing_command;
 523   if ((p != NULL) && (access (p, F_OK) != 0))
 524     p = NULL;
 525
 526   return p;
 527 }
 528
 529 static void
 530 core_files_info (struct target_ops *t)
 531 {
 532   print_section_info (t, core_bfd);
 533 }
 534 \f
 535 /* If mourn is being called in all the right places, this could be say
 536    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 537
 538 static int
 539 ignore (CORE_ADDR addr, char *contents)
 540 {
 541   return 0;
 542 }
 543
 544
 545 /* Okay, let's be honest: threads gleaned from a core file aren't
 546    exactly lively, are they?  On the other hand, if we don't claim
 547    that each & every one is alive, then we don't get any of them
 548    to appear in an "info thread" command, which is quite a useful
 549    behaviour.
 550  */
 551 static int
 552 core_file_thread_alive (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 (void)
 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 (void)
 598 {
 599   init_core_ops ();
 600
 601   if (!coreops_suppress_target)
 602     add_target (&core_ops);
 603 }