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 /* Get the registers out of a core file.  This is the machine-
 377    independent part.  Fetch_core_registers is the machine-dependent
 378    part, typically implemented in the xm-file for each architecture.  */
 379
 380 /* We just get all the registers, so we don't use regno.  */
 381
 382 /* ARGSUSED */
 383 static void
 384 get_core_registers (regno)
 385      int regno;
 386 {
 387   sec_ptr reg_sec;
 388   unsigned size;
 389   char *the_regs;
 390   char secname[30];
 391
 392   if (core_vec == NULL)
 393     {
 394       fprintf_filtered (gdb_stderr,
 395                      "Can't fetch registers from this type of core file\n");
 396       return;
 397     }
 398
 399   /* Thread support.  If inferior_pid is non-zero, then we have found a core
 400      file with threads (or multiple processes).  In that case, we need to
 401      use the appropriate register section, else we just use `.reg'. */
 402
 403   /* XXX - same thing needs to be done for floating-point (.reg2) sections. */
 404
 405   if (inferior_pid)
 406     sprintf (secname, ".reg/%d", inferior_pid);
 407   else
 408     strcpy (secname, ".reg");
 409
 410   reg_sec = bfd_get_section_by_name (core_bfd, secname);
 411   if (!reg_sec)
 412     goto cant;
 413   size = bfd_section_size (core_bfd, reg_sec);
 414   the_regs = alloca (size);
 415   if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr) 0, size) &&
 416       core_vec->core_read_registers != NULL)
 417     {
 418       (core_vec->core_read_registers (the_regs, size, 0,
 419                                 (unsigned) bfd_section_vma (abfd, reg_sec)));
 420     }
 421   else
 422     {
 423     cant:
 424       fprintf_filtered (gdb_stderr,
 425                         "Couldn't fetch registers from core file: %s\n",
 426                         bfd_errmsg (bfd_get_error ()));
 427     }
 428
 429   /* Now do it again for the float registers, if they exist.  */
 430   reg_sec = bfd_get_section_by_name (core_bfd, ".reg2");
 431   if (reg_sec)
 432     {
 433       size = bfd_section_size (core_bfd, reg_sec);
 434       the_regs = alloca (size);
 435       if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr) 0, size) &&
 436           core_vec->core_read_registers != NULL)
 437         {
 438           (core_vec->core_read_registers (the_regs, size, 2,
 439                                (unsigned) bfd_section_vma (abfd, reg_sec)));
 440         }
 441       else
 442         {
 443           fprintf_filtered (gdb_stderr,
 444                        "Couldn't fetch register set 2 from core file: %s\n",
 445                             bfd_errmsg (bfd_get_error ()));
 446         }
 447     }
 448   registers_fetched ();
 449 }
 450
 451 static char *
 452 core_file_to_sym_file (core)
 453      char *core;
 454 {
 455   CONST char *failing_command;
 456   char *p;
 457   char *temp;
 458   bfd *temp_bfd;
 459   int scratch_chan;
 460
 461   if (!core)
 462     error ("No core file specified.");
 463
 464   core = tilde_expand (core);
 465   if (core[0] != '/')
 466     {
 467       temp = concat (current_directory, "/", core, NULL);
 468       core = temp;
 469     }
 470
 471   scratch_chan = open (core, write_files ? O_RDWR : O_RDONLY, 0);
 472   if (scratch_chan < 0)
 473     perror_with_name (core);
 474
 475   temp_bfd = bfd_fdopenr (core, gnutarget, scratch_chan);
 476   if (temp_bfd == NULL)
 477     perror_with_name (core);
 478
 479   if (!bfd_check_format (temp_bfd, bfd_core))
 480     {
 481       /* Do it after the err msg */
 482       /* FIXME: should be checking for errors from bfd_close (for one thing,
 483          on error it does not free all the storage associated with the
 484          bfd).  */
 485       make_cleanup ((make_cleanup_func) bfd_close, temp_bfd);
 486       error ("\"%s\" is not a core dump: %s",
 487              core, bfd_errmsg (bfd_get_error ()));
 488     }
 489
 490   /* Find the data section */
 491   if (build_section_table (temp_bfd, &core_ops.to_sections,
 492                            &core_ops.to_sections_end))
 493     error ("\"%s\": Can't find sections: %s",
 494            bfd_get_filename (temp_bfd), bfd_errmsg (bfd_get_error ()));
 495
 496   failing_command = bfd_core_file_failing_command (temp_bfd);
 497
 498   bfd_close (temp_bfd);
 499
 500   /* If we found a filename, remember that it is probably saved
 501      relative to the executable that created it.  If working directory
 502      isn't there now, we may not be able to find the executable.  Rather
 503      than trying to be sauve about finding it, just check if the file
 504      exists where we are now.  If not, then punt and tell our client
 505      we couldn't find the sym file.
 506    */
 507   p = (char *) failing_command;
 508   if ((p != NULL) && (access (p, F_OK) != 0))
 509     p = NULL;
 510
 511   return p;
 512 }
 513
 514 static void
 515 core_files_info (t)
 516      struct target_ops *t;
 517 {
 518   print_section_info (t, core_bfd);
 519 }
 520 \f
 521 /* If mourn is being called in all the right places, this could be say
 522    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 523
 524 static int
 525 ignore (addr, contents)
 526      CORE_ADDR addr;
 527      char *contents;
 528 {
 529   return 0;
 530 }
 531
 532
 533 /* Okay, let's be honest: threads gleaned from a core file aren't
 534    exactly lively, are they?  On the other hand, if we don't claim
 535    that each & every one is alive, then we don't get any of them
 536    to appear in an "info thread" command, which is quite a useful
 537    behaviour.
 538  */
 539 static int
 540 core_file_thread_alive (tid)
 541      int tid;
 542 {
 543   return 1;
 544 }
 545
 546 /* Fill in core_ops with its defined operations and properties.  */
 547
 548 static void
 549 init_core_ops ()
 550 {
 551   core_ops.to_shortname = "core";
 552   core_ops.to_longname = "Local core dump file";
 553   core_ops.to_doc =
 554     "Use a core file as a target.  Specify the filename of the core file.";
 555   core_ops.to_open = core_open;
 556   core_ops.to_close = core_close;
 557   core_ops.to_attach = find_default_attach;
 558   core_ops.to_require_attach = find_default_require_attach;
 559   core_ops.to_detach = core_detach;
 560   core_ops.to_require_detach = find_default_require_detach;
 561   core_ops.to_fetch_registers = get_core_registers;
 562   core_ops.to_xfer_memory = xfer_memory;
 563   core_ops.to_files_info = core_files_info;
 564   core_ops.to_insert_breakpoint = ignore;
 565   core_ops.to_remove_breakpoint = ignore;
 566   core_ops.to_create_inferior = find_default_create_inferior;
 567   core_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
 568   core_ops.to_thread_alive = core_file_thread_alive;
 569   core_ops.to_core_file_to_sym_file = core_file_to_sym_file;
 570   core_ops.to_stratum = core_stratum;
 571   core_ops.to_has_memory = 1;
 572   core_ops.to_has_stack = 1;
 573   core_ops.to_has_registers = 1;
 574   core_ops.to_magic = OPS_MAGIC;
 575 }
 576
 577 /* non-zero if we should not do the add_target call in
 578    _initialize_corelow; not initialized (i.e., bss) so that
 579    the target can initialize it (i.e., data) if appropriate.
 580    This needs to be set at compile time because we don't know
 581    for sure whether the target's initialize routine is called
 582    before us or after us. */
 583 int coreops_suppress_target;
 584
 585 void
 586 _initialize_corelow ()
 587 {
 588   init_core_ops ();
 589
 590   if (!coreops_suppress_target)
 591     add_target (&core_ops);
 592 }