gdb/corelow.c

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