gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2
   3    Copyright (C) 1986-2013 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "gdb_string.h"
  23 #include <errno.h>
  24 #include <signal.h>
  25 #include <fcntl.h>
  26 #ifdef HAVE_SYS_FILE_H
  27 #include <sys/file.h>           /* needed for F_OK and friends */
  28 #endif
  29 #include "frame.h"              /* required by inferior.h */
  30 #include "inferior.h"
  31 #include "symtab.h"
  32 #include "command.h"
  33 #include "bfd.h"
  34 #include "target.h"
  35 #include "gdbcore.h"
  36 #include "gdbthread.h"
  37 #include "regcache.h"
  38 #include "regset.h"
  39 #include "symfile.h"
  40 #include "exec.h"
  41 #include "readline/readline.h"
  42 #include "gdb_assert.h"
  43 #include "exceptions.h"
  44 #include "solib.h"
  45 #include "filenames.h"
  46 #include "progspace.h"
  47 #include "objfiles.h"
  48 #include "gdb_bfd.h"
  49 #include "completer.h"
  50 #include "filestuff.h"
  51
  52 #ifndef O_LARGEFILE
  53 #define O_LARGEFILE 0
  54 #endif
  55
  56 /* List of all available core_fns.  On gdb startup, each core file
  57    register reader calls deprecated_add_core_fns() to register
  58    information on each core format it is prepared to read.  */
  59
  60 static struct core_fns *core_file_fns = NULL;
  61
  62 /* The core_fns for a core file handler that is prepared to read the
  63    core file currently open on core_bfd.  */
  64
  65 static struct core_fns *core_vec = NULL;
  66
  67 /* FIXME: kettenis/20031023: Eventually this variable should
  68    disappear.  */
  69
  70 static struct gdbarch *core_gdbarch = NULL;
  71
  72 /* Per-core data.  Currently, only the section table.  Note that these
  73    target sections are *not* mapped in the current address spaces' set
  74    of target sections --- those should come only from pure executable
  75    or shared library bfds.  The core bfd sections are an
  76    implementation detail of the core target, just like ptrace is for
  77    unix child targets.  */
  78 static struct target_section_table *core_data;
  79
  80 static void core_files_info (struct target_ops *);
  81
  82 static struct core_fns *sniff_core_bfd (bfd *);
  83
  84 static int gdb_check_format (bfd *);
  85
  86 static void core_open (char *, int);
  87
  88 static void core_detach (struct target_ops *ops, char *, int);
  89
  90 static void core_close (void);
  91
  92 static void core_close_cleanup (void *ignore);
  93
  94 static void add_to_thread_list (bfd *, asection *, void *);
  95
  96 static void init_core_ops (void);
  97
  98 void _initialize_corelow (void);
  99
 100 static struct target_ops core_ops;
 101
 102 /* An arbitrary identifier for the core inferior.  */
 103 #define CORELOW_PID 1
 104
 105 /* Link a new core_fns into the global core_file_fns list.  Called on
 106    gdb startup by the _initialize routine in each core file register
 107    reader, to register information about each format the reader is
 108    prepared to handle.  */
 109
 110 void
 111 deprecated_add_core_fns (struct core_fns *cf)
 112 {
 113   cf->next = core_file_fns;
 114   core_file_fns = cf;
 115 }
 116
 117 /* The default function that core file handlers can use to examine a
 118    core file BFD and decide whether or not to accept the job of
 119    reading the core file.  */
 120
 121 int
 122 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
 123 {
 124   int result;
 125
 126   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
 127   return (result);
 128 }
 129
 130 /* Walk through the list of core functions to find a set that can
 131    handle the core file open on ABFD.  Returns pointer to set that is
 132    selected.  */
 133
 134 static struct core_fns *
 135 sniff_core_bfd (bfd *abfd)
 136 {
 137   struct core_fns *cf;
 138   struct core_fns *yummy = NULL;
 139   int matches = 0;;
 140
 141   /* Don't sniff if we have support for register sets in
 142      CORE_GDBARCH.  */
 143   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 144     return NULL;
 145
 146   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 147     {
 148       if (cf->core_sniffer (cf, abfd))
 149         {
 150           yummy = cf;
 151           matches++;
 152         }
 153     }
 154   if (matches > 1)
 155     {
 156       warning (_("\"%s\": ambiguous core format, %d handlers match"),
 157                bfd_get_filename (abfd), matches);
 158     }
 159   else if (matches == 0)
 160     error (_("\"%s\": no core file handler recognizes format"),
 161            bfd_get_filename (abfd));
 162
 163   return (yummy);
 164 }
 165
 166 /* The default is to reject every core file format we see.  Either
 167    BFD has to recognize it, or we have to provide a function in the
 168    core file handler that recognizes it.  */
 169
 170 int
 171 default_check_format (bfd *abfd)
 172 {
 173   return (0);
 174 }
 175
 176 /* Attempt to recognize core file formats that BFD rejects.  */
 177
 178 static int
 179 gdb_check_format (bfd *abfd)
 180 {
 181   struct core_fns *cf;
 182
 183   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 184     {
 185       if (cf->check_format (abfd))
 186         {
 187           return (1);
 188         }
 189     }
 190   return (0);
 191 }
 192
 193 /* Discard all vestiges of any previous core file and mark data and
 194    stack spaces as empty.  */
 195
 196 static void
 197 core_close (void)
 198 {
 199   if (core_bfd)
 200     {
 201       int pid = ptid_get_pid (inferior_ptid);
 202       inferior_ptid = null_ptid;    /* Avoid confusion from thread
 203                                        stuff.  */
 204       if (pid != 0)
 205         exit_inferior_silent (pid);
 206
 207       /* Clear out solib state while the bfd is still open.  See
 208          comments in clear_solib in solib.c.  */
 209       clear_solib ();
 210
 211       if (core_data)
 212         {
 213           xfree (core_data->sections);
 214           xfree (core_data);
 215           core_data = NULL;
 216         }
 217
 218       gdb_bfd_unref (core_bfd);
 219       core_bfd = NULL;
 220     }
 221   core_vec = NULL;
 222   core_gdbarch = NULL;
 223 }
 224
 225 static void
 226 core_close_cleanup (void *ignore)
 227 {
 228   core_close ();
 229 }
 230
 231 /* Look for sections whose names start with `.reg/' so that we can
 232    extract the list of threads in a core file.  */
 233
 234 static void
 235 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
 236 {
 237   ptid_t ptid;
 238   int core_tid;
 239   int pid, lwpid;
 240   asection *reg_sect = (asection *) reg_sect_arg;
 241   int fake_pid_p = 0;
 242   struct inferior *inf;
 243
 244   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 245     return;
 246
 247   core_tid = atoi (bfd_section_name (abfd, asect) + 5);
 248
 249   pid = bfd_core_file_pid (core_bfd);
 250   if (pid == 0)
 251     {
 252       fake_pid_p = 1;
 253       pid = CORELOW_PID;
 254     }
 255
 256   lwpid = core_tid;
 257
 258   inf = current_inferior ();
 259   if (inf->pid == 0)
 260     {
 261       inferior_appeared (inf, pid);
 262       inf->fake_pid_p = fake_pid_p;
 263     }
 264
 265   ptid = ptid_build (pid, lwpid, 0);
 266
 267   add_thread (ptid);
 268
 269 /* Warning, Will Robinson, looking at BFD private data! */
 270
 271   if (reg_sect != NULL
 272       && asect->filepos == reg_sect->filepos)   /* Did we find .reg?  */
 273     inferior_ptid = ptid;                       /* Yes, make it current.  */
 274 }
 275
 276 /* This routine opens and sets up the core file bfd.  */
 277
 278 static void
 279 core_open (char *filename, int from_tty)
 280 {
 281   const char *p;
 282   int siggy;
 283   struct cleanup *old_chain;
 284   char *temp;
 285   bfd *temp_bfd;
 286   int scratch_chan;
 287   int flags;
 288   volatile struct gdb_exception except;
 289
 290   target_preopen (from_tty);
 291   if (!filename)
 292     {
 293       if (core_bfd)
 294         error (_("No core file specified.  (Use `detach' "
 295                  "to stop debugging a core file.)"));
 296       else
 297         error (_("No core file specified."));
 298     }
 299
 300   filename = tilde_expand (filename);
 301   if (!IS_ABSOLUTE_PATH (filename))
 302     {
 303       temp = concat (current_directory, "/",
 304                      filename, (char *) NULL);
 305       xfree (filename);
 306       filename = temp;
 307     }
 308
 309   old_chain = make_cleanup (xfree, filename);
 310
 311   flags = O_BINARY | O_LARGEFILE;
 312   if (write_files)
 313     flags |= O_RDWR;
 314   else
 315     flags |= O_RDONLY;
 316   scratch_chan = gdb_open_cloexec (filename, flags, 0);
 317   if (scratch_chan < 0)
 318     perror_with_name (filename);
 319
 320   temp_bfd = gdb_bfd_fopen (filename, gnutarget,
 321                             write_files ? FOPEN_RUB : FOPEN_RB,
 322                             scratch_chan);
 323   if (temp_bfd == NULL)
 324     perror_with_name (filename);
 325
 326   if (!bfd_check_format (temp_bfd, bfd_core)
 327       && !gdb_check_format (temp_bfd))
 328     {
 329       /* Do it after the err msg */
 330       /* FIXME: should be checking for errors from bfd_close (for one
 331          thing, on error it does not free all the storage associated
 332          with the bfd).  */
 333       make_cleanup_bfd_unref (temp_bfd);
 334       error (_("\"%s\" is not a core dump: %s"),
 335              filename, bfd_errmsg (bfd_get_error ()));
 336     }
 337
 338   /* Looks semi-reasonable.  Toss the old core file and work on the
 339      new.  */
 340
 341   do_cleanups (old_chain);
 342   unpush_target (&core_ops);
 343   core_bfd = temp_bfd;
 344   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 345
 346   core_gdbarch = gdbarch_from_bfd (core_bfd);
 347
 348   /* Find a suitable core file handler to munch on core_bfd */
 349   core_vec = sniff_core_bfd (core_bfd);
 350
 351   validate_files ();
 352
 353   core_data = XZALLOC (struct target_section_table);
 354
 355   /* Find the data section */
 356   if (build_section_table (core_bfd,
 357                            &core_data->sections,
 358                            &core_data->sections_end))
 359     error (_("\"%s\": Can't find sections: %s"),
 360            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 361
 362   /* If we have no exec file, try to set the architecture from the
 363      core file.  We don't do this unconditionally since an exec file
 364      typically contains more information that helps us determine the
 365      architecture than a core file.  */
 366   if (!exec_bfd)
 367     set_gdbarch_from_file (core_bfd);
 368
 369   push_target (&core_ops);
 370   discard_cleanups (old_chain);
 371
 372   /* Do this before acknowledging the inferior, so if
 373      post_create_inferior throws (can happen easilly if you're loading
 374      a core file with the wrong exec), we aren't left with threads
 375      from the previous inferior.  */
 376   init_thread_list ();
 377
 378   inferior_ptid = null_ptid;
 379
 380   /* Need to flush the register cache (and the frame cache) from a
 381      previous debug session.  If inferior_ptid ends up the same as the
 382      last debug session --- e.g., b foo; run; gcore core1; step; gcore
 383      core2; core core1; core core2 --- then there's potential for
 384      get_current_regcache to return the cached regcache of the
 385      previous session, and the frame cache being stale.  */
 386   registers_changed ();
 387
 388   /* Build up thread list from BFD sections, and possibly set the
 389      current thread to the .reg/NN section matching the .reg
 390      section.  */
 391   bfd_map_over_sections (core_bfd, add_to_thread_list,
 392                          bfd_get_section_by_name (core_bfd, ".reg"));
 393
 394   if (ptid_equal (inferior_ptid, null_ptid))
 395     {
 396       /* Either we found no .reg/NN section, and hence we have a
 397          non-threaded core (single-threaded, from gdb's perspective),
 398          or for some reason add_to_thread_list couldn't determine
 399          which was the "main" thread.  The latter case shouldn't
 400          usually happen, but we're dealing with input here, which can
 401          always be broken in different ways.  */
 402       struct thread_info *thread = first_thread_of_process (-1);
 403
 404       if (thread == NULL)
 405         {
 406           inferior_appeared (current_inferior (), CORELOW_PID);
 407           inferior_ptid = pid_to_ptid (CORELOW_PID);
 408           add_thread_silent (inferior_ptid);
 409         }
 410       else
 411         switch_to_thread (thread->ptid);
 412     }
 413
 414   post_create_inferior (&core_ops, from_tty);
 415
 416   /* Now go through the target stack looking for threads since there
 417      may be a thread_stratum target loaded on top of target core by
 418      now.  The layer above should claim threads found in the BFD
 419      sections.  */
 420   TRY_CATCH (except, RETURN_MASK_ERROR)
 421     {
 422       target_find_new_threads ();
 423     }
 424
 425   if (except.reason < 0)
 426     exception_print (gdb_stderr, except);
 427
 428   p = bfd_core_file_failing_command (core_bfd);
 429   if (p)
 430     printf_filtered (_("Core was generated by `%s'.\n"), p);
 431
 432   /* Clearing any previous state of convenience variables.  */
 433   clear_exit_convenience_vars ();
 434
 435   siggy = bfd_core_file_failing_signal (core_bfd);
 436   if (siggy > 0)
 437     {
 438       /* If we don't have a CORE_GDBARCH to work with, assume a native
 439          core (map gdb_signal from host signals).  If we do have
 440          CORE_GDBARCH to work with, but no gdb_signal_from_target
 441          implementation for that gdbarch, as a fallback measure,
 442          assume the host signal mapping.  It'll be correct for native
 443          cores, but most likely incorrect for cross-cores.  */
 444       enum gdb_signal sig = (core_gdbarch != NULL
 445                              && gdbarch_gdb_signal_from_target_p (core_gdbarch)
 446                              ? gdbarch_gdb_signal_from_target (core_gdbarch,
 447                                                                siggy)
 448                              : gdb_signal_from_host (siggy));
 449
 450       printf_filtered (_("Program terminated with signal %s, %s.\n"),
 451                        gdb_signal_to_name (sig), gdb_signal_to_string (sig));
 452
 453       /* Set the value of the internal variable $_exitsignal,
 454          which holds the signal uncaught by the inferior.  */
 455       set_internalvar_integer (lookup_internalvar ("_exitsignal"),
 456                                siggy);
 457     }
 458
 459   /* Fetch all registers from core file.  */
 460   target_fetch_registers (get_current_regcache (), -1);
 461
 462   /* Now, set up the frame cache, and print the top of stack.  */
 463   reinit_frame_cache ();
 464   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
 465 }
 466
 467 static void
 468 core_detach (struct target_ops *ops, char *args, int from_tty)
 469 {
 470   if (args)
 471     error (_("Too many arguments"));
 472   unpush_target (ops);
 473   reinit_frame_cache ();
 474   if (from_tty)
 475     printf_filtered (_("No core file now.\n"));
 476 }
 477
 478 /* Try to retrieve registers from a section in core_bfd, and supply
 479    them to core_vec->core_read_registers, as the register set numbered
 480    WHICH.
 481
 482    If inferior_ptid's lwp member is zero, do the single-threaded
 483    thing: look for a section named NAME.  If inferior_ptid's lwp
 484    member is non-zero, do the multi-threaded thing: look for a section
 485    named "NAME/LWP", where LWP is the shortest ASCII decimal
 486    representation of inferior_ptid's lwp member.
 487
 488    HUMAN_NAME is a human-readable name for the kind of registers the
 489    NAME section contains, for use in error messages.
 490
 491    If REQUIRED is non-zero, print an error if the core file doesn't
 492    have a section by the appropriate name.  Otherwise, just do
 493    nothing.  */
 494
 495 static void
 496 get_core_register_section (struct regcache *regcache,
 497                            const char *name,
 498                            int which,
 499                            const char *human_name,
 500                            int required)
 501 {
 502   static char *section_name = NULL;
 503   struct bfd_section *section;
 504   bfd_size_type size;
 505   char *contents;
 506
 507   xfree (section_name);
 508
 509   if (ptid_get_lwp (inferior_ptid))
 510     section_name = xstrprintf ("%s/%ld", name,
 511                                ptid_get_lwp (inferior_ptid));
 512   else
 513     section_name = xstrdup (name);
 514
 515   section = bfd_get_section_by_name (core_bfd, section_name);
 516   if (! section)
 517     {
 518       if (required)
 519         warning (_("Couldn't find %s registers in core file."),
 520                  human_name);
 521       return;
 522     }
 523
 524   size = bfd_section_size (core_bfd, section);
 525   contents = alloca (size);
 526   if (! bfd_get_section_contents (core_bfd, section, contents,
 527                                   (file_ptr) 0, size))
 528     {
 529       warning (_("Couldn't read %s registers from `%s' section in core file."),
 530                human_name, name);
 531       return;
 532     }
 533
 534   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 535     {
 536       const struct regset *regset;
 537
 538       regset = gdbarch_regset_from_core_section (core_gdbarch,
 539                                                  name, size);
 540       if (regset == NULL)
 541         {
 542           if (required)
 543             warning (_("Couldn't recognize %s registers in core file."),
 544                      human_name);
 545           return;
 546         }
 547
 548       regset->supply_regset (regset, regcache, -1, contents, size);
 549       return;
 550     }
 551
 552   gdb_assert (core_vec);
 553   core_vec->core_read_registers (regcache, contents, size, which,
 554                                  ((CORE_ADDR)
 555                                   bfd_section_vma (core_bfd, section)));
 556 }
 557
 558
 559 /* Get the registers out of a core file.  This is the machine-
 560    independent part.  Fetch_core_registers is the machine-dependent
 561    part, typically implemented in the xm-file for each
 562    architecture.  */
 563
 564 /* We just get all the registers, so we don't use regno.  */
 565
 566 static void
 567 get_core_registers (struct target_ops *ops,
 568                     struct regcache *regcache, int regno)
 569 {
 570   struct core_regset_section *sect_list;
 571   int i;
 572
 573   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 574       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 575     {
 576       fprintf_filtered (gdb_stderr,
 577                      "Can't fetch registers from this type of core file\n");
 578       return;
 579     }
 580
 581   sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache));
 582   if (sect_list)
 583     while (sect_list->sect_name != NULL)
 584       {
 585         if (strcmp (sect_list->sect_name, ".reg") == 0)
 586           get_core_register_section (regcache, sect_list->sect_name,
 587                                      0, sect_list->human_name, 1);
 588         else if (strcmp (sect_list->sect_name, ".reg2") == 0)
 589           get_core_register_section (regcache, sect_list->sect_name,
 590                                      2, sect_list->human_name, 0);
 591         else
 592           get_core_register_section (regcache, sect_list->sect_name,
 593                                      3, sect_list->human_name, 0);
 594
 595         sect_list++;
 596       }
 597
 598   else
 599     {
 600       get_core_register_section (regcache,
 601                                  ".reg", 0, "general-purpose", 1);
 602       get_core_register_section (regcache,
 603                                  ".reg2", 2, "floating-point", 0);
 604     }
 605
 606   /* Mark all registers not found in the core as unavailable.  */
 607   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 608     if (regcache_register_status (regcache, i) == REG_UNKNOWN)
 609       regcache_raw_supply (regcache, i, NULL);
 610 }
 611
 612 static void
 613 core_files_info (struct target_ops *t)
 614 {
 615   print_section_info (core_data, core_bfd);
 616 }
 617 \f
 618 struct spuid_list
 619 {
 620   gdb_byte *buf;
 621   ULONGEST offset;
 622   LONGEST len;
 623   ULONGEST pos;
 624   ULONGEST written;
 625 };
 626
 627 static void
 628 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
 629 {
 630   struct spuid_list *list = list_p;
 631   enum bfd_endian byte_order
 632     = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 633   int fd, pos = 0;
 634
 635   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
 636   if (pos == 0)
 637     return;
 638
 639   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
 640     {
 641       store_unsigned_integer (list->buf + list->pos - list->offset,
 642                               4, byte_order, fd);
 643       list->written += 4;
 644     }
 645   list->pos += 4;
 646 }
 647
 648 /* Read siginfo data from the core, if possible.  Returns -1 on
 649    failure.  Otherwise, returns the number of bytes read.  ABFD is the
 650    core file's BFD; READBUF, OFFSET, and LEN are all as specified by
 651    the to_xfer_partial interface.  */
 652
 653 static LONGEST
 654 get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
 655 {
 656   asection *section;
 657   char *section_name;
 658   const char *name = ".note.linuxcore.siginfo";
 659
 660   if (ptid_get_lwp (inferior_ptid))
 661     section_name = xstrprintf ("%s/%ld", name,
 662                                ptid_get_lwp (inferior_ptid));
 663   else
 664     section_name = xstrdup (name);
 665
 666   section = bfd_get_section_by_name (abfd, section_name);
 667   xfree (section_name);
 668   if (section == NULL)
 669     return -1;
 670
 671   if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
 672     return -1;
 673
 674   return len;
 675 }
 676
 677 static LONGEST
 678 core_xfer_partial (struct target_ops *ops, enum target_object object,
 679                    const char *annex, gdb_byte *readbuf,
 680                    const gdb_byte *writebuf, ULONGEST offset,
 681                    LONGEST len)
 682 {
 683   switch (object)
 684     {
 685     case TARGET_OBJECT_MEMORY:
 686       return section_table_xfer_memory_partial (readbuf, writebuf,
 687                                                 offset, len,
 688                                                 core_data->sections,
 689                                                 core_data->sections_end,
 690                                                 NULL);
 691
 692     case TARGET_OBJECT_AUXV:
 693       if (readbuf)
 694         {
 695           /* When the aux vector is stored in core file, BFD
 696              represents this with a fake section called ".auxv".  */
 697
 698           struct bfd_section *section;
 699           bfd_size_type size;
 700
 701           section = bfd_get_section_by_name (core_bfd, ".auxv");
 702           if (section == NULL)
 703             return -1;
 704
 705           size = bfd_section_size (core_bfd, section);
 706           if (offset >= size)
 707             return 0;
 708           size -= offset;
 709           if (size > len)
 710             size = len;
 711           if (size > 0
 712               && !bfd_get_section_contents (core_bfd, section, readbuf,
 713                                             (file_ptr) offset, size))
 714             {
 715               warning (_("Couldn't read NT_AUXV note in core file."));
 716               return -1;
 717             }
 718
 719           return size;
 720         }
 721       return -1;
 722
 723     case TARGET_OBJECT_WCOOKIE:
 724       if (readbuf)
 725         {
 726           /* When the StackGhost cookie is stored in core file, BFD
 727              represents this with a fake section called
 728              ".wcookie".  */
 729
 730           struct bfd_section *section;
 731           bfd_size_type size;
 732
 733           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 734           if (section == NULL)
 735             return -1;
 736
 737           size = bfd_section_size (core_bfd, section);
 738           if (offset >= size)
 739             return 0;
 740           size -= offset;
 741           if (size > len)
 742             size = len;
 743           if (size > 0
 744               && !bfd_get_section_contents (core_bfd, section, readbuf,
 745                                             (file_ptr) offset, size))
 746             {
 747               warning (_("Couldn't read StackGhost cookie in core file."));
 748               return -1;
 749             }
 750
 751           return size;
 752         }
 753       return -1;
 754
 755     case TARGET_OBJECT_LIBRARIES:
 756       if (core_gdbarch
 757           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 758         {
 759           if (writebuf)
 760             return -1;
 761           return
 762             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 763                                                 readbuf, offset, len);
 764         }
 765       /* FALL THROUGH */
 766
 767     case TARGET_OBJECT_LIBRARIES_AIX:
 768       if (core_gdbarch
 769           && gdbarch_core_xfer_shared_libraries_aix_p (core_gdbarch))
 770         {
 771           if (writebuf)
 772             return -1;
 773           return
 774             gdbarch_core_xfer_shared_libraries_aix (core_gdbarch,
 775                                                     readbuf, offset, len);
 776         }
 777       /* FALL THROUGH */
 778
 779     case TARGET_OBJECT_SPU:
 780       if (readbuf && annex)
 781         {
 782           /* When the SPU contexts are stored in a core file, BFD
 783              represents this with a fake section called
 784              "SPU/<annex>".  */
 785
 786           struct bfd_section *section;
 787           bfd_size_type size;
 788           char sectionstr[100];
 789
 790           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
 791
 792           section = bfd_get_section_by_name (core_bfd, sectionstr);
 793           if (section == NULL)
 794             return -1;
 795
 796           size = bfd_section_size (core_bfd, section);
 797           if (offset >= size)
 798             return 0;
 799           size -= offset;
 800           if (size > len)
 801             size = len;
 802           if (size > 0
 803               && !bfd_get_section_contents (core_bfd, section, readbuf,
 804                                             (file_ptr) offset, size))
 805             {
 806               warning (_("Couldn't read SPU section in core file."));
 807               return -1;
 808             }
 809
 810           return size;
 811         }
 812       else if (readbuf)
 813         {
 814           /* NULL annex requests list of all present spuids.  */
 815           struct spuid_list list;
 816
 817           list.buf = readbuf;
 818           list.offset = offset;
 819           list.len = len;
 820           list.pos = 0;
 821           list.written = 0;
 822           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
 823           return list.written;
 824         }
 825       return -1;
 826
 827     case TARGET_OBJECT_SIGNAL_INFO:
 828       if (readbuf)
 829         return get_core_siginfo (core_bfd, readbuf, offset, len);
 830       return -1;
 831
 832     default:
 833       if (ops->beneath != NULL)
 834         return ops->beneath->to_xfer_partial (ops->beneath, object,
 835                                               annex, readbuf,
 836                                               writebuf, offset, len);
 837       return -1;
 838     }
 839 }
 840
 841 \f
 842 /* If mourn is being called in all the right places, this could be say
 843    `gdb internal error' (since generic_mourn calls
 844    breakpoint_init_inferior).  */
 845
 846 static int
 847 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
 848 {
 849   return 0;
 850 }
 851
 852
 853 /* Okay, let's be honest: threads gleaned from a core file aren't
 854    exactly lively, are they?  On the other hand, if we don't claim
 855    that each & every one is alive, then we don't get any of them
 856    to appear in an "info thread" command, which is quite a useful
 857    behaviour.
 858  */
 859 static int
 860 core_thread_alive (struct target_ops *ops, ptid_t ptid)
 861 {
 862   return 1;
 863 }
 864
 865 /* Ask the current architecture what it knows about this core file.
 866    That will be used, in turn, to pick a better architecture.  This
 867    wrapper could be avoided if targets got a chance to specialize
 868    core_ops.  */
 869
 870 static const struct target_desc *
 871 core_read_description (struct target_ops *target)
 872 {
 873   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
 874     return gdbarch_core_read_description (core_gdbarch,
 875                                           target, core_bfd);
 876
 877   return NULL;
 878 }
 879
 880 static char *
 881 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
 882 {
 883   static char buf[64];
 884   struct inferior *inf;
 885   int pid;
 886
 887   /* The preferred way is to have a gdbarch/OS specific
 888      implementation.  */
 889   if (core_gdbarch
 890       && gdbarch_core_pid_to_str_p (core_gdbarch))
 891     return gdbarch_core_pid_to_str (core_gdbarch, ptid);
 892
 893   /* Otherwise, if we don't have one, we'll just fallback to
 894      "process", with normal_pid_to_str.  */
 895
 896   /* Try the LWPID field first.  */
 897   pid = ptid_get_lwp (ptid);
 898   if (pid != 0)
 899     return normal_pid_to_str (pid_to_ptid (pid));
 900
 901   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
 902      only if it isn't a fake PID.  */
 903   inf = find_inferior_pid (ptid_get_pid (ptid));
 904   if (inf != NULL && !inf->fake_pid_p)
 905     return normal_pid_to_str (ptid);
 906
 907   /* No luck.  We simply don't have a valid PID to print.  */
 908   xsnprintf (buf, sizeof buf, "<main task>");
 909   return buf;
 910 }
 911
 912 static int
 913 core_has_memory (struct target_ops *ops)
 914 {
 915   return (core_bfd != NULL);
 916 }
 917
 918 static int
 919 core_has_stack (struct target_ops *ops)
 920 {
 921   return (core_bfd != NULL);
 922 }
 923
 924 static int
 925 core_has_registers (struct target_ops *ops)
 926 {
 927   return (core_bfd != NULL);
 928 }
 929
 930 /* Implement the to_info_proc method.  */
 931
 932 static void
 933 core_info_proc (struct target_ops *ops, char *args, enum info_proc_what request)
 934 {
 935   struct gdbarch *gdbarch = get_current_arch ();
 936
 937   /* Since this is the core file target, call the 'core_info_proc'
 938      method on gdbarch, not 'info_proc'.  */
 939   if (gdbarch_core_info_proc_p (gdbarch))
 940     gdbarch_core_info_proc (gdbarch, args, request);
 941 }
 942
 943 /* Fill in core_ops with its defined operations and properties.  */
 944
 945 static void
 946 init_core_ops (void)
 947 {
 948   core_ops.to_shortname = "core";
 949   core_ops.to_longname = "Local core dump file";
 950   core_ops.to_doc =
 951     "Use a core file as a target.  Specify the filename of the core file.";
 952   core_ops.to_open = core_open;
 953   core_ops.to_close = core_close;
 954   core_ops.to_attach = find_default_attach;
 955   core_ops.to_detach = core_detach;
 956   core_ops.to_fetch_registers = get_core_registers;
 957   core_ops.to_xfer_partial = core_xfer_partial;
 958   core_ops.to_files_info = core_files_info;
 959   core_ops.to_insert_breakpoint = ignore;
 960   core_ops.to_remove_breakpoint = ignore;
 961   core_ops.to_create_inferior = find_default_create_inferior;
 962   core_ops.to_thread_alive = core_thread_alive;
 963   core_ops.to_read_description = core_read_description;
 964   core_ops.to_pid_to_str = core_pid_to_str;
 965   core_ops.to_stratum = process_stratum;
 966   core_ops.to_has_memory = core_has_memory;
 967   core_ops.to_has_stack = core_has_stack;
 968   core_ops.to_has_registers = core_has_registers;
 969   core_ops.to_info_proc = core_info_proc;
 970   core_ops.to_magic = OPS_MAGIC;
 971
 972   if (core_target)
 973     internal_error (__FILE__, __LINE__,
 974                     _("init_core_ops: core target already exists (\"%s\")."),
 975                     core_target->to_longname);
 976   core_target = &core_ops;
 977 }
 978
 979 void
 980 _initialize_corelow (void)
 981 {
 982   init_core_ops ();
 983
 984   add_target_with_completer (&core_ops, filename_completer);
 985 }