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