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