gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   4    1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.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 #include "regset.h"
  41 #include "symfile.h"
  42 #include "exec.h"
  43 #include "readline/readline.h"
  44 #include "gdb_assert.h"
  45 #include "exceptions.h"
  46 #include "solib.h"
  47 #include "filenames.h"
  48 #include "progspace.h"
  49 #include "objfiles.h"
  50
  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 core
  63    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 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 /* True if we needed to fake the pid of the loaded core inferior.  */
  81 static int core_has_fake_pid = 0;
  82
  83 static void core_files_info (struct target_ops *);
  84
  85 static struct core_fns *sniff_core_bfd (bfd *);
  86
  87 static int gdb_check_format (bfd *);
  88
  89 static void core_open (char *, int);
  90
  91 static void core_detach (struct target_ops *ops, char *, int);
  92
  93 static void core_close (int);
  94
  95 static void core_close_cleanup (void *ignore);
  96
  97 static void add_to_thread_list (bfd *, asection *, void *);
  98
  99 static void init_core_ops (void);
 100
 101 void _initialize_corelow (void);
 102
 103 static struct target_ops core_ops;
 104
 105 /* An arbitrary identifier for the core inferior.  */
 106 #define CORELOW_PID 1
 107
 108 /* Link a new core_fns into the global core_file_fns list.  Called on gdb
 109    startup by the _initialize routine in each core file register reader, to
 110    register information about each format the the reader is prepared to
 111    handle. */
 112
 113 void
 114 deprecated_add_core_fns (struct core_fns *cf)
 115 {
 116   cf->next = core_file_fns;
 117   core_file_fns = cf;
 118 }
 119
 120 /* The default function that core file handlers can use to examine a
 121    core file BFD and decide whether or not to accept the job of
 122    reading the core file. */
 123
 124 int
 125 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
 126 {
 127   int result;
 128
 129   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
 130   return (result);
 131 }
 132
 133 /* Walk through the list of core functions to find a set that can
 134    handle the core file open on ABFD.  Default to the first one in the
 135    list if nothing matches.  Returns pointer to set that is
 136    selected. */
 137
 138 static struct core_fns *
 139 sniff_core_bfd (bfd *abfd)
 140 {
 141   struct core_fns *cf;
 142   struct core_fns *yummy = NULL;
 143   int matches = 0;;
 144
 145   /* Don't sniff if we have support for register sets in CORE_GDBARCH.  */
 146   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 147     return NULL;
 148
 149   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 150     {
 151       if (cf->core_sniffer (cf, abfd))
 152         {
 153           yummy = cf;
 154           matches++;
 155         }
 156     }
 157   if (matches > 1)
 158     {
 159       warning (_("\"%s\": ambiguous core format, %d handlers match"),
 160                bfd_get_filename (abfd), matches);
 161     }
 162   else if (matches == 0)
 163     {
 164       warning (_("\"%s\": no core file handler recognizes format, using default"),
 165                bfd_get_filename (abfd));
 166     }
 167   if (yummy == NULL)
 168     {
 169       yummy = core_file_fns;
 170     }
 171   return (yummy);
 172 }
 173
 174 /* The default is to reject every core file format we see.  Either
 175    BFD has to recognize it, or we have to provide a function in the
 176    core file handler that recognizes it. */
 177
 178 int
 179 default_check_format (bfd *abfd)
 180 {
 181   return (0);
 182 }
 183
 184 /* Attempt to recognize core file formats that BFD rejects. */
 185
 186 static int
 187 gdb_check_format (bfd *abfd)
 188 {
 189   struct core_fns *cf;
 190
 191   for (cf = core_file_fns; cf != NULL; cf = cf->next)
 192     {
 193       if (cf->check_format (abfd))
 194         {
 195           return (1);
 196         }
 197     }
 198   return (0);
 199 }
 200
 201 /* Discard all vestiges of any previous core file and mark data and stack
 202    spaces as empty.  */
 203
 204 static void
 205 core_close (int quitting)
 206 {
 207   char *name;
 208
 209   if (core_bfd)
 210     {
 211       int pid = ptid_get_pid (inferior_ptid);
 212       inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff */
 213       exit_inferior_silent (pid);
 214
 215       /* Clear out solib state while the bfd is still open. See
 216          comments in clear_solib in solib.c. */
 217       clear_solib ();
 218
 219       xfree (core_data->sections);
 220       xfree (core_data);
 221       core_data = NULL;
 222       core_has_fake_pid = 0;
 223
 224       name = bfd_get_filename (core_bfd);
 225       gdb_bfd_close_or_warn (core_bfd);
 226       xfree (name);
 227       core_bfd = NULL;
 228     }
 229   core_vec = NULL;
 230   core_gdbarch = NULL;
 231 }
 232
 233 static void
 234 core_close_cleanup (void *ignore)
 235 {
 236   core_close (0/*ignored*/);
 237 }
 238
 239 /* Look for sections whose names start with `.reg/' so that we can extract the
 240    list of threads in a core file.  */
 241
 242 static void
 243 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
 244 {
 245   ptid_t ptid;
 246   int core_tid;
 247   int pid, lwpid;
 248   asection *reg_sect = (asection *) reg_sect_arg;
 249
 250   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 251     return;
 252
 253   core_tid = atoi (bfd_section_name (abfd, asect) + 5);
 254
 255   pid = bfd_core_file_pid (core_bfd);
 256   if (pid == 0)
 257     {
 258       core_has_fake_pid = 1;
 259       pid = CORELOW_PID;
 260     }
 261
 262   lwpid = core_tid;
 263
 264   if (current_inferior ()->pid == 0)
 265     inferior_appeared (current_inferior (), pid);
 266
 267   ptid = ptid_build (pid, lwpid, 0);
 268
 269   add_thread (ptid);
 270
 271 /* Warning, Will Robinson, looking at BFD private data! */
 272
 273   if (reg_sect != NULL
 274       && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
 275     inferior_ptid = ptid;                        /* Yes, make it current */
 276 }
 277
 278 /* This routine opens and sets up the core file bfd.  */
 279
 280 static void
 281 core_open (char *filename, int from_tty)
 282 {
 283   const char *p;
 284   int siggy;
 285   struct cleanup *old_chain;
 286   char *temp;
 287   bfd *temp_bfd;
 288   int scratch_chan;
 289   int flags;
 290
 291   target_preopen (from_tty);
 292   if (!filename)
 293     {
 294       if (core_bfd)
 295         error (_("No core file specified.  (Use `detach' 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, "/", filename, (char *)NULL);
 304       xfree (filename);
 305       filename = temp;
 306     }
 307
 308   old_chain = make_cleanup (xfree, filename);
 309
 310   flags = O_BINARY | O_LARGEFILE;
 311   if (write_files)
 312     flags |= O_RDWR;
 313   else
 314     flags |= O_RDONLY;
 315   scratch_chan = open (filename, flags, 0);
 316   if (scratch_chan < 0)
 317     perror_with_name (filename);
 318
 319   temp_bfd = bfd_fopen (filename, gnutarget,
 320                         write_files ? FOPEN_RUB : FOPEN_RB,
 321                         scratch_chan);
 322   if (temp_bfd == NULL)
 323     perror_with_name (filename);
 324
 325   if (!bfd_check_format (temp_bfd, bfd_core)
 326       && !gdb_check_format (temp_bfd))
 327     {
 328       /* Do it after the err msg */
 329       /* FIXME: should be checking for errors from bfd_close (for one thing,
 330          on error it does not free all the storage associated with the
 331          bfd).  */
 332       make_cleanup_bfd_close (temp_bfd);
 333       error (_("\"%s\" is not a core dump: %s"),
 334              filename, bfd_errmsg (bfd_get_error ()));
 335     }
 336
 337   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 338
 339   discard_cleanups (old_chain); /* Don't free filename any more */
 340   unpush_target (&core_ops);
 341   core_bfd = temp_bfd;
 342   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 343
 344   /* FIXME: kettenis/20031023: This is very dangerous.  The
 345      CORE_GDBARCH that results from this call may very well be
 346      different from CURRENT_GDBARCH.  However, its methods may only
 347      work if it is selected as the current architecture, because they
 348      rely on swapped data (see gdbarch.c).  We should get rid of that
 349      swapped data.  */
 350   core_gdbarch = gdbarch_from_bfd (core_bfd);
 351
 352   /* Find a suitable core file handler to munch on core_bfd */
 353   core_vec = sniff_core_bfd (core_bfd);
 354
 355   validate_files ();
 356
 357   core_data = XZALLOC (struct target_section_table);
 358
 359   /* Find the data section */
 360   if (build_section_table (core_bfd,
 361                            &core_data->sections, &core_data->sections_end))
 362     error (_("\"%s\": Can't find sections: %s"),
 363            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 364
 365   /* If we have no exec file, try to set the architecture from the
 366      core file.  We don't do this unconditionally since an exec file
 367      typically contains more information that helps us determine the
 368      architecture than a core file.  */
 369   if (!exec_bfd)
 370     set_gdbarch_from_file (core_bfd);
 371
 372   push_target (&core_ops);
 373   discard_cleanups (old_chain);
 374
 375   /* Do this before acknowledging the inferior, so if
 376      post_create_inferior throws (can happen easilly if you're loading
 377      a core file with the wrong exec), we aren't left with threads
 378      from the previous inferior.  */
 379   init_thread_list ();
 380
 381   inferior_ptid = null_ptid;
 382   core_has_fake_pid = 0;
 383
 384   /* Need to flush the register cache (and the frame cache) from a
 385      previous debug session.  If inferior_ptid ends up the same as the
 386      last debug session --- e.g., b foo; run; gcore core1; step; gcore
 387      core2; core core1; core core2 --- then there's potential for
 388      get_current_regcache to return the cached regcache of the
 389      previous session, and the frame cache being stale.  */
 390   registers_changed ();
 391
 392   /* Build up thread list from BFD sections, and possibly set the
 393      current thread to the .reg/NN section matching the .reg
 394      section. */
 395   bfd_map_over_sections (core_bfd, add_to_thread_list,
 396                          bfd_get_section_by_name (core_bfd, ".reg"));
 397
 398   if (ptid_equal (inferior_ptid, null_ptid))
 399     {
 400       /* Either we found no .reg/NN section, and hence we have a
 401          non-threaded core (single-threaded, from gdb's perspective),
 402          or for some reason add_to_thread_list couldn't determine
 403          which was the "main" thread.  The latter case shouldn't
 404          usually happen, but we're dealing with input here, which can
 405          always be broken in different ways.  */
 406       struct thread_info *thread = first_thread_of_process (-1);
 407
 408       if (thread == NULL)
 409         {
 410           inferior_appeared (current_inferior (), CORELOW_PID);
 411           inferior_ptid = pid_to_ptid (CORELOW_PID);
 412           add_thread_silent (inferior_ptid);
 413         }
 414       else
 415         switch_to_thread (thread->ptid);
 416     }
 417
 418   post_create_inferior (&core_ops, from_tty);
 419
 420   /* Now go through the target stack looking for threads since there
 421      may be a thread_stratum target loaded on top of target core by
 422      now.  The layer above should claim threads found in the BFD
 423      sections.  */
 424   target_find_new_threads ();
 425
 426   p = bfd_core_file_failing_command (core_bfd);
 427   if (p)
 428     printf_filtered (_("Core was generated by `%s'.\n"), p);
 429
 430   siggy = bfd_core_file_failing_signal (core_bfd);
 431   if (siggy > 0)
 432     /* NOTE: target_signal_from_host() converts a target signal value
 433        into gdb's internal signal value.  Unfortunately gdb's internal
 434        value is called ``target_signal'' and this function got the
 435        name ..._from_host(). */
 436     printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
 437                      target_signal_to_string (
 438                        (core_gdbarch != NULL) ?
 439                         gdbarch_target_signal_from_host (core_gdbarch, siggy)
 440                         : siggy));
 441
 442   /* Fetch all registers from core file.  */
 443   target_fetch_registers (get_current_regcache (), -1);
 444
 445   /* Now, set up the frame cache, and print the top of stack.  */
 446   reinit_frame_cache ();
 447   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 448 }
 449
 450 static void
 451 core_detach (struct target_ops *ops, char *args, int from_tty)
 452 {
 453   if (args)
 454     error (_("Too many arguments"));
 455   unpush_target (ops);
 456   reinit_frame_cache ();
 457   if (from_tty)
 458     printf_filtered (_("No core file now.\n"));
 459 }
 460
 461 #ifdef DEPRECATED_IBM6000_TARGET
 462
 463 /* Resize the core memory's section table, by NUM_ADDED.  Returns a
 464    pointer into the first new slot.  This will not be necessary when
 465    the rs6000 target is converted to use the standard solib
 466    framework.  */
 467
 468 struct target_section *
 469 deprecated_core_resize_section_table (int num_added)
 470 {
 471   int old_count;
 472
 473   old_count = resize_section_table (core_data, num_added);
 474   return core_data->sections + old_count;
 475 }
 476
 477 #endif
 478
 479 /* Try to retrieve registers from a section in core_bfd, and supply
 480    them to core_vec->core_read_registers, as the register set numbered
 481    WHICH.
 482
 483    If inferior_ptid's lwp member is zero, do the single-threaded
 484    thing: look for a section named NAME.  If inferior_ptid's lwp
 485    member is non-zero, do the multi-threaded thing: look for a section
 486    named "NAME/LWP", where LWP is the shortest ASCII decimal
 487    representation of inferior_ptid's lwp member.
 488
 489    HUMAN_NAME is a human-readable name for the kind of registers the
 490    NAME section contains, for use in error messages.
 491
 492    If REQUIRED is non-zero, print an error if the core file doesn't
 493    have a section by the appropriate name.  Otherwise, just do 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, ptid_get_lwp (inferior_ptid));
 511   else
 512     section_name = xstrdup (name);
 513
 514   section = bfd_get_section_by_name (core_bfd, section_name);
 515   if (! section)
 516     {
 517       if (required)
 518         warning (_("Couldn't find %s registers in core file."), human_name);
 519       return;
 520     }
 521
 522   size = bfd_section_size (core_bfd, section);
 523   contents = alloca (size);
 524   if (! bfd_get_section_contents (core_bfd, section, contents,
 525                                   (file_ptr) 0, size))
 526     {
 527       warning (_("Couldn't read %s registers from `%s' section in core file."),
 528                human_name, name);
 529       return;
 530     }
 531
 532   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 533     {
 534       const struct regset *regset;
 535
 536       regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
 537       if (regset == NULL)
 538         {
 539           if (required)
 540             warning (_("Couldn't recognize %s registers in core file."),
 541                      human_name);
 542           return;
 543         }
 544
 545       regset->supply_regset (regset, regcache, -1, contents, size);
 546       return;
 547     }
 548
 549   gdb_assert (core_vec);
 550   core_vec->core_read_registers (regcache, contents, size, which,
 551                                  ((CORE_ADDR)
 552                                   bfd_section_vma (core_bfd, section)));
 553 }
 554
 555
 556 /* Get the registers out of a core file.  This is the machine-
 557    independent part.  Fetch_core_registers is the machine-dependent
 558    part, typically implemented in the xm-file for each architecture.  */
 559
 560 /* We just get all the registers, so we don't use regno.  */
 561
 562 static void
 563 get_core_registers (struct target_ops *ops,
 564                     struct regcache *regcache, int regno)
 565 {
 566   struct core_regset_section *sect_list;
 567   int i;
 568
 569   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 570       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 571     {
 572       fprintf_filtered (gdb_stderr,
 573                      "Can't fetch registers from this type of core file\n");
 574       return;
 575     }
 576
 577   sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache));
 578   if (sect_list)
 579     while (sect_list->sect_name != NULL)
 580       {
 581         if (strcmp (sect_list->sect_name, ".reg") == 0)
 582           get_core_register_section (regcache, sect_list->sect_name,
 583                                      0, sect_list->human_name, 1);
 584         else if (strcmp (sect_list->sect_name, ".reg2") == 0)
 585           get_core_register_section (regcache, sect_list->sect_name,
 586                                      2, sect_list->human_name, 0);
 587         else
 588           get_core_register_section (regcache, sect_list->sect_name,
 589                                      3, sect_list->human_name, 0);
 590
 591         sect_list++;
 592       }
 593
 594   else
 595     {
 596       get_core_register_section (regcache,
 597                                  ".reg", 0, "general-purpose", 1);
 598       get_core_register_section (regcache,
 599                                  ".reg2", 2, "floating-point", 0);
 600     }
 601
 602   /* Supply dummy value for all registers not found in the core.  */
 603   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 604     if (!regcache_valid_p (regcache, i))
 605       regcache_raw_supply (regcache, i, NULL);
 606 }
 607
 608 static void
 609 core_files_info (struct target_ops *t)
 610 {
 611   print_section_info (core_data, core_bfd);
 612 }
 613 \f
 614 struct spuid_list
 615 {
 616   gdb_byte *buf;
 617   ULONGEST offset;
 618   LONGEST len;
 619   ULONGEST pos;
 620   ULONGEST written;
 621 };
 622
 623 static void
 624 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
 625 {
 626   struct spuid_list *list = list_p;
 627   enum bfd_endian byte_order
 628     = bfd_big_endian (abfd)? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 629   int fd, pos = 0;
 630
 631   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
 632   if (pos == 0)
 633     return;
 634
 635   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
 636     {
 637       store_unsigned_integer (list->buf + list->pos - list->offset,
 638                               4, byte_order, fd);
 639       list->written += 4;
 640     }
 641   list->pos += 4;
 642 }
 643
 644 static LONGEST
 645 core_xfer_partial (struct target_ops *ops, enum target_object object,
 646                    const char *annex, gdb_byte *readbuf,
 647                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
 648 {
 649   switch (object)
 650     {
 651     case TARGET_OBJECT_MEMORY:
 652       return section_table_xfer_memory_partial (readbuf, writebuf,
 653                                                 offset, len,
 654                                                 core_data->sections,
 655                                                 core_data->sections_end,
 656                                                 NULL);
 657
 658     case TARGET_OBJECT_AUXV:
 659       if (readbuf)
 660         {
 661           /* When the aux vector is stored in core file, BFD
 662              represents this with a fake section called ".auxv".  */
 663
 664           struct bfd_section *section;
 665           bfd_size_type size;
 666
 667           section = bfd_get_section_by_name (core_bfd, ".auxv");
 668           if (section == NULL)
 669             return -1;
 670
 671           size = bfd_section_size (core_bfd, section);
 672           if (offset >= size)
 673             return 0;
 674           size -= offset;
 675           if (size > len)
 676             size = len;
 677           if (size > 0
 678               && !bfd_get_section_contents (core_bfd, section, readbuf,
 679                                             (file_ptr) offset, size))
 680             {
 681               warning (_("Couldn't read NT_AUXV note in core file."));
 682               return -1;
 683             }
 684
 685           return size;
 686         }
 687       return -1;
 688
 689     case TARGET_OBJECT_WCOOKIE:
 690       if (readbuf)
 691         {
 692           /* When the StackGhost cookie is stored in core file, BFD
 693              represents this with a fake section called ".wcookie".  */
 694
 695           struct bfd_section *section;
 696           bfd_size_type size;
 697
 698           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 699           if (section == NULL)
 700             return -1;
 701
 702           size = bfd_section_size (core_bfd, section);
 703           if (offset >= size)
 704             return 0;
 705           size -= offset;
 706           if (size > len)
 707             size = len;
 708           if (size > 0
 709               && !bfd_get_section_contents (core_bfd, section, readbuf,
 710                                             (file_ptr) offset, size))
 711             {
 712               warning (_("Couldn't read StackGhost cookie in core file."));
 713               return -1;
 714             }
 715
 716           return size;
 717         }
 718       return -1;
 719
 720     case TARGET_OBJECT_LIBRARIES:
 721       if (core_gdbarch
 722           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 723         {
 724           if (writebuf)
 725             return -1;
 726           return
 727             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 728                                                 readbuf, offset, len);
 729         }
 730       /* FALL THROUGH */
 731
 732     case TARGET_OBJECT_SPU:
 733       if (readbuf && annex)
 734         {
 735           /* When the SPU contexts are stored in a core file, BFD
 736              represents this with a fake section called "SPU/<annex>".  */
 737
 738           struct bfd_section *section;
 739           bfd_size_type size;
 740           char sectionstr[100];
 741
 742           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
 743
 744           section = bfd_get_section_by_name (core_bfd, sectionstr);
 745           if (section == NULL)
 746             return -1;
 747
 748           size = bfd_section_size (core_bfd, section);
 749           if (offset >= size)
 750             return 0;
 751           size -= offset;
 752           if (size > len)
 753             size = len;
 754           if (size > 0
 755               && !bfd_get_section_contents (core_bfd, section, readbuf,
 756                                             (file_ptr) offset, size))
 757             {
 758               warning (_("Couldn't read SPU section in core file."));
 759               return -1;
 760             }
 761
 762           return size;
 763         }
 764       else if (readbuf)
 765         {
 766           /* NULL annex requests list of all present spuids.  */
 767           struct spuid_list list;
 768
 769           list.buf = readbuf;
 770           list.offset = offset;
 771           list.len = len;
 772           list.pos = 0;
 773           list.written = 0;
 774           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
 775           return list.written;
 776         }
 777       return -1;
 778
 779     default:
 780       if (ops->beneath != NULL)
 781         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
 782                                               readbuf, writebuf, offset, len);
 783       return -1;
 784     }
 785 }
 786
 787 \f
 788 /* If mourn is being called in all the right places, this could be say
 789    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
 790
 791 static int
 792 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
 793 {
 794   return 0;
 795 }
 796
 797
 798 /* Okay, let's be honest: threads gleaned from a core file aren't
 799    exactly lively, are they?  On the other hand, if we don't claim
 800    that each & every one is alive, then we don't get any of them
 801    to appear in an "info thread" command, which is quite a useful
 802    behaviour.
 803  */
 804 static int
 805 core_thread_alive (struct target_ops *ops, ptid_t ptid)
 806 {
 807   return 1;
 808 }
 809
 810 /* Ask the current architecture what it knows about this core file.
 811    That will be used, in turn, to pick a better architecture.  This
 812    wrapper could be avoided if targets got a chance to specialize
 813    core_ops.  */
 814
 815 static const struct target_desc *
 816 core_read_description (struct target_ops *target)
 817 {
 818   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
 819     return gdbarch_core_read_description (core_gdbarch, target, core_bfd);
 820
 821   return NULL;
 822 }
 823
 824 static char *
 825 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
 826 {
 827   static char buf[64];
 828   int pid;
 829
 830   /* The preferred way is to have a gdbarch/OS specific
 831      implementation.  */
 832   if (core_gdbarch
 833       && gdbarch_core_pid_to_str_p (core_gdbarch))
 834     return gdbarch_core_pid_to_str (core_gdbarch, ptid);
 835
 836   /* Otherwise, if we don't have one, we'll just fallback to
 837      "process", with normal_pid_to_str.  */
 838
 839   /* Try the LWPID field first.  */
 840   pid = ptid_get_lwp (ptid);
 841   if (pid != 0)
 842     return normal_pid_to_str (pid_to_ptid (pid));
 843
 844   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
 845      only if it isn't a fake PID.  */
 846   if (!core_has_fake_pid)
 847     return normal_pid_to_str (ptid);
 848
 849   /* No luck.  We simply don't have a valid PID to print.  */
 850   xsnprintf (buf, sizeof buf, "<main task>");
 851   return buf;
 852 }
 853
 854 static int
 855 core_has_memory (struct target_ops *ops)
 856 {
 857   return (core_bfd != NULL);
 858 }
 859
 860 static int
 861 core_has_stack (struct target_ops *ops)
 862 {
 863   return (core_bfd != NULL);
 864 }
 865
 866 static int
 867 core_has_registers (struct target_ops *ops)
 868 {
 869   return (core_bfd != NULL);
 870 }
 871
 872 /* Fill in core_ops with its defined operations and properties.  */
 873
 874 static void
 875 init_core_ops (void)
 876 {
 877   core_ops.to_shortname = "core";
 878   core_ops.to_longname = "Local core dump file";
 879   core_ops.to_doc =
 880     "Use a core file as a target.  Specify the filename of the core file.";
 881   core_ops.to_open = core_open;
 882   core_ops.to_close = core_close;
 883   core_ops.to_attach = find_default_attach;
 884   core_ops.to_detach = core_detach;
 885   core_ops.to_fetch_registers = get_core_registers;
 886   core_ops.to_xfer_partial = core_xfer_partial;
 887   core_ops.to_files_info = core_files_info;
 888   core_ops.to_insert_breakpoint = ignore;
 889   core_ops.to_remove_breakpoint = ignore;
 890   core_ops.to_create_inferior = find_default_create_inferior;
 891   core_ops.to_thread_alive = core_thread_alive;
 892   core_ops.to_read_description = core_read_description;
 893   core_ops.to_pid_to_str = core_pid_to_str;
 894   core_ops.to_stratum = process_stratum;
 895   core_ops.to_has_memory = core_has_memory;
 896   core_ops.to_has_stack = core_has_stack;
 897   core_ops.to_has_registers = core_has_registers;
 898   core_ops.to_magic = OPS_MAGIC;
 899
 900   if (core_target)
 901     internal_error (__FILE__, __LINE__,
 902                     _("init_core_ops: core target already exists (\"%s\")."),
 903                     core_target->to_longname);
 904   core_target = &core_ops;
 905 }
 906
 907 void
 908 _initialize_corelow (void)
 909 {
 910   init_core_ops ();
 911
 912   add_target (&core_ops);
 913 }