gdb/corelow.c

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