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