gdb/corelow.c

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