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