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