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