gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2
   3    Copyright (C) 1986-2018 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, int from_tty)
 468 {
 469   unpush_target (ops);
 470   reinit_frame_cache ();
 471   if (from_tty)
 472     printf_filtered (_("No core file now.\n"));
 473 }
 474
 475 /* Try to retrieve registers from a section in core_bfd, and supply
 476    them to core_vec->core_read_registers, as the register set numbered
 477    WHICH.
 478
 479    If ptid's lwp member is zero, do the single-threaded
 480    thing: look for a section named NAME.  If ptid's lwp
 481    member is non-zero, do the multi-threaded thing: look for a section
 482    named "NAME/LWP", where LWP is the shortest ASCII decimal
 483    representation of ptid's lwp member.
 484
 485    HUMAN_NAME is a human-readable name for the kind of registers the
 486    NAME section contains, for use in error messages.
 487
 488    If REQUIRED is non-zero, print an error if the core file doesn't
 489    have a section by the appropriate name.  Otherwise, just do
 490    nothing.  */
 491
 492 static void
 493 get_core_register_section (struct regcache *regcache,
 494                            const struct regset *regset,
 495                            const char *name,
 496                            int min_size,
 497                            int which,
 498                            const char *human_name,
 499                            int required)
 500 {
 501   struct bfd_section *section;
 502   bfd_size_type size;
 503   char *contents;
 504   bool variable_size_section = (regset != NULL
 505                                 && regset->flags & REGSET_VARIABLE_SIZE);
 506
 507   thread_section_name section_name (name, regcache->ptid ());
 508
 509   section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
 510   if (! section)
 511     {
 512       if (required)
 513         warning (_("Couldn't find %s registers in core file."),
 514                  human_name);
 515       return;
 516     }
 517
 518   size = bfd_section_size (core_bfd, section);
 519   if (size < min_size)
 520     {
 521       warning (_("Section `%s' in core file too small."),
 522                section_name.c_str ());
 523       return;
 524     }
 525   if (size != min_size && !variable_size_section)
 526     {
 527       warning (_("Unexpected size of section `%s' in core file."),
 528                section_name.c_str ());
 529     }
 530
 531   contents = (char *) alloca (size);
 532   if (! bfd_get_section_contents (core_bfd, section, contents,
 533                                   (file_ptr) 0, size))
 534     {
 535       warning (_("Couldn't read %s registers from `%s' section in core file."),
 536                human_name, section_name.c_str ());
 537       return;
 538     }
 539
 540   if (regset != NULL)
 541     {
 542       regset->supply_regset (regset, regcache, -1, contents, size);
 543       return;
 544     }
 545
 546   gdb_assert (core_vec);
 547   core_vec->core_read_registers (regcache, contents, size, which,
 548                                  ((CORE_ADDR)
 549                                   bfd_section_vma (core_bfd, section)));
 550 }
 551
 552 /* Callback for get_core_registers that handles a single core file
 553    register note section. */
 554
 555 static void
 556 get_core_registers_cb (const char *sect_name, int size,
 557                        const struct regset *regset,
 558                        const char *human_name, void *cb_data)
 559 {
 560   struct regcache *regcache = (struct regcache *) cb_data;
 561   int required = 0;
 562
 563   if (strcmp (sect_name, ".reg") == 0)
 564     {
 565       required = 1;
 566       if (human_name == NULL)
 567         human_name = "general-purpose";
 568     }
 569   else if (strcmp (sect_name, ".reg2") == 0)
 570     {
 571       if (human_name == NULL)
 572         human_name = "floating-point";
 573     }
 574
 575   /* The 'which' parameter is only used when no regset is provided.
 576      Thus we just set it to -1. */
 577   get_core_register_section (regcache, regset, sect_name,
 578                              size, -1, human_name, required);
 579 }
 580
 581 /* Get the registers out of a core file.  This is the machine-
 582    independent part.  Fetch_core_registers is the machine-dependent
 583    part, typically implemented in the xm-file for each
 584    architecture.  */
 585
 586 /* We just get all the registers, so we don't use regno.  */
 587
 588 static void
 589 get_core_registers (struct target_ops *ops,
 590                     struct regcache *regcache, int regno)
 591 {
 592   int i;
 593   struct gdbarch *gdbarch;
 594
 595   if (!(core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
 596       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 597     {
 598       fprintf_filtered (gdb_stderr,
 599                      "Can't fetch registers from this type of core file\n");
 600       return;
 601     }
 602
 603   gdbarch = regcache->arch ();
 604   if (gdbarch_iterate_over_regset_sections_p (gdbarch))
 605     gdbarch_iterate_over_regset_sections (gdbarch,
 606                                           get_core_registers_cb,
 607                                           (void *) regcache, NULL);
 608   else
 609     {
 610       get_core_register_section (regcache, NULL,
 611                                  ".reg", 0, 0, "general-purpose", 1);
 612       get_core_register_section (regcache, NULL,
 613                                  ".reg2", 0, 2, "floating-point", 0);
 614     }
 615
 616   /* Mark all registers not found in the core as unavailable.  */
 617   for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
 618     if (regcache_register_status (regcache, i) == REG_UNKNOWN)
 619       regcache_raw_supply (regcache, i, NULL);
 620 }
 621
 622 static void
 623 core_files_info (struct target_ops *t)
 624 {
 625   print_section_info (core_data, core_bfd);
 626 }
 627 \f
 628 struct spuid_list
 629 {
 630   gdb_byte *buf;
 631   ULONGEST offset;
 632   LONGEST len;
 633   ULONGEST pos;
 634   ULONGEST written;
 635 };
 636
 637 static void
 638 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
 639 {
 640   struct spuid_list *list = (struct spuid_list *) list_p;
 641   enum bfd_endian byte_order
 642     = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 643   int fd, pos = 0;
 644
 645   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
 646   if (pos == 0)
 647     return;
 648
 649   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
 650     {
 651       store_unsigned_integer (list->buf + list->pos - list->offset,
 652                               4, byte_order, fd);
 653       list->written += 4;
 654     }
 655   list->pos += 4;
 656 }
 657
 658 static enum target_xfer_status
 659 core_xfer_partial (struct target_ops *ops, enum target_object object,
 660                    const char *annex, gdb_byte *readbuf,
 661                    const gdb_byte *writebuf, ULONGEST offset,
 662                    ULONGEST len, ULONGEST *xfered_len)
 663 {
 664   switch (object)
 665     {
 666     case TARGET_OBJECT_MEMORY:
 667       return section_table_xfer_memory_partial (readbuf, writebuf,
 668                                                 offset, len, xfered_len,
 669                                                 core_data->sections,
 670                                                 core_data->sections_end,
 671                                                 NULL);
 672
 673     case TARGET_OBJECT_AUXV:
 674       if (readbuf)
 675         {
 676           /* When the aux vector is stored in core file, BFD
 677              represents this with a fake section called ".auxv".  */
 678
 679           struct bfd_section *section;
 680           bfd_size_type size;
 681
 682           section = bfd_get_section_by_name (core_bfd, ".auxv");
 683           if (section == NULL)
 684             return TARGET_XFER_E_IO;
 685
 686           size = bfd_section_size (core_bfd, section);
 687           if (offset >= size)
 688             return TARGET_XFER_EOF;
 689           size -= offset;
 690           if (size > len)
 691             size = len;
 692
 693           if (size == 0)
 694             return TARGET_XFER_EOF;
 695           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 696                                          (file_ptr) offset, size))
 697             {
 698               warning (_("Couldn't read NT_AUXV note in core file."));
 699               return TARGET_XFER_E_IO;
 700             }
 701
 702           *xfered_len = (ULONGEST) size;
 703           return TARGET_XFER_OK;
 704         }
 705       return TARGET_XFER_E_IO;
 706
 707     case TARGET_OBJECT_WCOOKIE:
 708       if (readbuf)
 709         {
 710           /* When the StackGhost cookie is stored in core file, BFD
 711              represents this with a fake section called
 712              ".wcookie".  */
 713
 714           struct bfd_section *section;
 715           bfd_size_type size;
 716
 717           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 718           if (section == NULL)
 719             return TARGET_XFER_E_IO;
 720
 721           size = bfd_section_size (core_bfd, section);
 722           if (offset >= size)
 723             return TARGET_XFER_EOF;
 724           size -= offset;
 725           if (size > len)
 726             size = len;
 727
 728           if (size == 0)
 729             return TARGET_XFER_EOF;
 730           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 731                                          (file_ptr) offset, size))
 732             {
 733               warning (_("Couldn't read StackGhost cookie in core file."));
 734               return TARGET_XFER_E_IO;
 735             }
 736
 737           *xfered_len = (ULONGEST) size;
 738           return TARGET_XFER_OK;
 739
 740         }
 741       return TARGET_XFER_E_IO;
 742
 743     case TARGET_OBJECT_LIBRARIES:
 744       if (core_gdbarch
 745           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 746         {
 747           if (writebuf)
 748             return TARGET_XFER_E_IO;
 749           else
 750             {
 751               *xfered_len = gdbarch_core_xfer_shared_libraries (core_gdbarch,
 752                                                                 readbuf,
 753                                                                 offset, len);
 754
 755               if (*xfered_len == 0)
 756                 return TARGET_XFER_EOF;
 757               else
 758                 return TARGET_XFER_OK;
 759             }
 760         }
 761       /* FALL THROUGH */
 762
 763     case TARGET_OBJECT_LIBRARIES_AIX:
 764       if (core_gdbarch
 765           && gdbarch_core_xfer_shared_libraries_aix_p (core_gdbarch))
 766         {
 767           if (writebuf)
 768             return TARGET_XFER_E_IO;
 769           else
 770             {
 771               *xfered_len
 772                 = gdbarch_core_xfer_shared_libraries_aix (core_gdbarch,
 773                                                           readbuf, offset,
 774                                                           len);
 775
 776               if (*xfered_len == 0)
 777                 return TARGET_XFER_EOF;
 778               else
 779                 return TARGET_XFER_OK;
 780             }
 781         }
 782       /* FALL THROUGH */
 783
 784     case TARGET_OBJECT_SPU:
 785       if (readbuf && annex)
 786         {
 787           /* When the SPU contexts are stored in a core file, BFD
 788              represents this with a fake section called
 789              "SPU/<annex>".  */
 790
 791           struct bfd_section *section;
 792           bfd_size_type size;
 793           char sectionstr[100];
 794
 795           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
 796
 797           section = bfd_get_section_by_name (core_bfd, sectionstr);
 798           if (section == NULL)
 799             return TARGET_XFER_E_IO;
 800
 801           size = bfd_section_size (core_bfd, section);
 802           if (offset >= size)
 803             return TARGET_XFER_EOF;
 804           size -= offset;
 805           if (size > len)
 806             size = len;
 807
 808           if (size == 0)
 809             return TARGET_XFER_EOF;
 810           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 811                                          (file_ptr) offset, size))
 812             {
 813               warning (_("Couldn't read SPU section in core file."));
 814               return TARGET_XFER_E_IO;
 815             }
 816
 817           *xfered_len = (ULONGEST) size;
 818           return TARGET_XFER_OK;
 819         }
 820       else if (readbuf)
 821         {
 822           /* NULL annex requests list of all present spuids.  */
 823           struct spuid_list list;
 824
 825           list.buf = readbuf;
 826           list.offset = offset;
 827           list.len = len;
 828           list.pos = 0;
 829           list.written = 0;
 830           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
 831
 832           if (list.written == 0)
 833             return TARGET_XFER_EOF;
 834           else
 835             {
 836               *xfered_len = (ULONGEST) list.written;
 837               return TARGET_XFER_OK;
 838             }
 839         }
 840       return TARGET_XFER_E_IO;
 841
 842     case TARGET_OBJECT_SIGNAL_INFO:
 843       if (readbuf)
 844         {
 845           if (core_gdbarch
 846               && gdbarch_core_xfer_siginfo_p (core_gdbarch))
 847             {
 848               LONGEST l = gdbarch_core_xfer_siginfo  (core_gdbarch, readbuf,
 849                                                       offset, len);
 850
 851               if (l >= 0)
 852                 {
 853                   *xfered_len = l;
 854                   if (l == 0)
 855                     return TARGET_XFER_EOF;
 856                   else
 857                     return TARGET_XFER_OK;
 858                 }
 859             }
 860         }
 861       return TARGET_XFER_E_IO;
 862
 863     default:
 864       return ops->beneath->to_xfer_partial (ops->beneath, object,
 865                                             annex, readbuf,
 866                                             writebuf, offset, len,
 867                                             xfered_len);
 868     }
 869 }
 870
 871 \f
 872 /* If mourn is being called in all the right places, this could be say
 873    `gdb internal error' (since generic_mourn calls
 874    breakpoint_init_inferior).  */
 875
 876 static int
 877 ignore (struct target_ops *ops, struct gdbarch *gdbarch,
 878         struct bp_target_info *bp_tgt)
 879 {
 880   return 0;
 881 }
 882
 883 /* Implement the to_remove_breakpoint method.  */
 884
 885 static int
 886 core_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
 887                         struct bp_target_info *bp_tgt,
 888                         enum remove_bp_reason reason)
 889 {
 890   return 0;
 891 }
 892
 893
 894 /* Okay, let's be honest: threads gleaned from a core file aren't
 895    exactly lively, are they?  On the other hand, if we don't claim
 896    that each & every one is alive, then we don't get any of them
 897    to appear in an "info thread" command, which is quite a useful
 898    behaviour.
 899  */
 900 static int
 901 core_thread_alive (struct target_ops *ops, ptid_t ptid)
 902 {
 903   return 1;
 904 }
 905
 906 /* Ask the current architecture what it knows about this core file.
 907    That will be used, in turn, to pick a better architecture.  This
 908    wrapper could be avoided if targets got a chance to specialize
 909    core_ops.  */
 910
 911 static const struct target_desc *
 912 core_read_description (struct target_ops *target)
 913 {
 914   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
 915     {
 916       const struct target_desc *result;
 917
 918       result = gdbarch_core_read_description (core_gdbarch,
 919                                               target, core_bfd);
 920       if (result != NULL)
 921         return result;
 922     }
 923
 924   return target->beneath->to_read_description (target->beneath);
 925 }
 926
 927 static const char *
 928 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
 929 {
 930   static char buf[64];
 931   struct inferior *inf;
 932   int pid;
 933
 934   /* The preferred way is to have a gdbarch/OS specific
 935      implementation.  */
 936   if (core_gdbarch
 937       && gdbarch_core_pid_to_str_p (core_gdbarch))
 938     return gdbarch_core_pid_to_str (core_gdbarch, ptid);
 939
 940   /* Otherwise, if we don't have one, we'll just fallback to
 941      "process", with normal_pid_to_str.  */
 942
 943   /* Try the LWPID field first.  */
 944   pid = ptid_get_lwp (ptid);
 945   if (pid != 0)
 946     return normal_pid_to_str (pid_to_ptid (pid));
 947
 948   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
 949      only if it isn't a fake PID.  */
 950   inf = find_inferior_ptid (ptid);
 951   if (inf != NULL && !inf->fake_pid_p)
 952     return normal_pid_to_str (ptid);
 953
 954   /* No luck.  We simply don't have a valid PID to print.  */
 955   xsnprintf (buf, sizeof buf, "<main task>");
 956   return buf;
 957 }
 958
 959 static const char *
 960 core_thread_name (struct target_ops *self, struct thread_info *thr)
 961 {
 962   if (core_gdbarch
 963       && gdbarch_core_thread_name_p (core_gdbarch))
 964     return gdbarch_core_thread_name (core_gdbarch, thr);
 965   return NULL;
 966 }
 967
 968 static int
 969 core_has_memory (struct target_ops *ops)
 970 {
 971   return (core_bfd != NULL);
 972 }
 973
 974 static int
 975 core_has_stack (struct target_ops *ops)
 976 {
 977   return (core_bfd != NULL);
 978 }
 979
 980 static int
 981 core_has_registers (struct target_ops *ops)
 982 {
 983   return (core_bfd != NULL);
 984 }
 985
 986 /* Implement the to_info_proc method.  */
 987
 988 static void
 989 core_info_proc (struct target_ops *ops, const char *args,
 990                 enum info_proc_what request)
 991 {
 992   struct gdbarch *gdbarch = get_current_arch ();
 993
 994   /* Since this is the core file target, call the 'core_info_proc'
 995      method on gdbarch, not 'info_proc'.  */
 996   if (gdbarch_core_info_proc_p (gdbarch))
 997     gdbarch_core_info_proc (gdbarch, args, request);
 998 }
 999
1000 /* Fill in core_ops with its defined operations and properties.  */
1001
1002 static void
1003 init_core_ops (void)
1004 {
1005   core_ops.to_shortname = "core";
1006   core_ops.to_longname = "Local core dump file";
1007   core_ops.to_doc =
1008     "Use a core file as a target.  Specify the filename of the core file.";
1009   core_ops.to_open = core_open;
1010   core_ops.to_close = core_close;
1011   core_ops.to_detach = core_detach;
1012   core_ops.to_fetch_registers = get_core_registers;
1013   core_ops.to_xfer_partial = core_xfer_partial;
1014   core_ops.to_files_info = core_files_info;
1015   core_ops.to_insert_breakpoint = ignore;
1016   core_ops.to_remove_breakpoint = core_remove_breakpoint;
1017   core_ops.to_thread_alive = core_thread_alive;
1018   core_ops.to_read_description = core_read_description;
1019   core_ops.to_pid_to_str = core_pid_to_str;
1020   core_ops.to_thread_name = core_thread_name;
1021   core_ops.to_stratum = process_stratum;
1022   core_ops.to_has_memory = core_has_memory;
1023   core_ops.to_has_stack = core_has_stack;
1024   core_ops.to_has_registers = core_has_registers;
1025   core_ops.to_info_proc = core_info_proc;
1026   core_ops.to_magic = OPS_MAGIC;
1027
1028   if (core_target)
1029     internal_error (__FILE__, __LINE__,
1030                     _("init_core_ops: core target already exists (\"%s\")."),
1031                     core_target->to_longname);
1032   core_target = &core_ops;
1033 }
1034
1035 void
1036 _initialize_corelow (void)
1037 {
1038   init_core_ops ();
1039
1040   add_target_with_completer (&core_ops, filename_completer);
1041 }