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