gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2
   3    Copyright (C) 1986-2013 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 "gdb_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
  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 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_open (char *, int);
  85
  86 static void core_detach (struct target_ops *ops, char *, int);
  87
  88 static void core_close (int);
  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 (int quitting)
 196 {
 197   char *name;
 198
 199   if (core_bfd)
 200     {
 201       int pid = ptid_get_pid (inferior_ptid);
 202       inferior_ptid = null_ptid;    /* Avoid confusion from thread
 203                                        stuff.  */
 204       if (pid != 0)
 205         exit_inferior_silent (pid);
 206
 207       /* Clear out solib state while the bfd is still open.  See
 208          comments in clear_solib in solib.c.  */
 209       clear_solib ();
 210
 211       if (core_data)
 212         {
 213           xfree (core_data->sections);
 214           xfree (core_data);
 215           core_data = NULL;
 216         }
 217
 218       gdb_bfd_unref (core_bfd);
 219       core_bfd = NULL;
 220     }
 221   core_vec = NULL;
 222   core_gdbarch = NULL;
 223 }
 224
 225 static void
 226 core_close_cleanup (void *ignore)
 227 {
 228   core_close (0/*ignored*/);
 229 }
 230
 231 /* Look for sections whose names start with `.reg/' so that we can
 232    extract the list of threads in a core file.  */
 233
 234 static void
 235 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
 236 {
 237   ptid_t ptid;
 238   int core_tid;
 239   int pid, lwpid;
 240   asection *reg_sect = (asection *) reg_sect_arg;
 241   int fake_pid_p = 0;
 242   struct inferior *inf;
 243
 244   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
 245     return;
 246
 247   core_tid = atoi (bfd_section_name (abfd, asect) + 5);
 248
 249   pid = bfd_core_file_pid (core_bfd);
 250   if (pid == 0)
 251     {
 252       fake_pid_p = 1;
 253       pid = CORELOW_PID;
 254     }
 255
 256   lwpid = core_tid;
 257
 258   inf = current_inferior ();
 259   if (inf->pid == 0)
 260     {
 261       inferior_appeared (inf, pid);
 262       inf->fake_pid_p = fake_pid_p;
 263     }
 264
 265   ptid = ptid_build (pid, lwpid, 0);
 266
 267   add_thread (ptid);
 268
 269 /* Warning, Will Robinson, looking at BFD private data! */
 270
 271   if (reg_sect != NULL
 272       && asect->filepos == reg_sect->filepos)   /* Did we find .reg?  */
 273     inferior_ptid = ptid;                       /* Yes, make it current.  */
 274 }
 275
 276 /* This routine opens and sets up the core file bfd.  */
 277
 278 static void
 279 core_open (char *filename, int from_tty)
 280 {
 281   const char *p;
 282   int siggy;
 283   struct cleanup *old_chain;
 284   char *temp;
 285   bfd *temp_bfd;
 286   int scratch_chan;
 287   int flags;
 288   volatile struct gdb_exception except;
 289
 290   target_preopen (from_tty);
 291   if (!filename)
 292     {
 293       if (core_bfd)
 294         error (_("No core file specified.  (Use `detach' "
 295                  "to stop debugging a core file.)"));
 296       else
 297         error (_("No core file specified."));
 298     }
 299
 300   filename = tilde_expand (filename);
 301   if (!IS_ABSOLUTE_PATH (filename))
 302     {
 303       temp = concat (current_directory, "/",
 304                      filename, (char *) NULL);
 305       xfree (filename);
 306       filename = temp;
 307     }
 308
 309   old_chain = make_cleanup (xfree, filename);
 310
 311   flags = O_BINARY | O_LARGEFILE;
 312   if (write_files)
 313     flags |= O_RDWR;
 314   else
 315     flags |= O_RDONLY;
 316   scratch_chan = open (filename, flags, 0);
 317   if (scratch_chan < 0)
 318     perror_with_name (filename);
 319
 320   temp_bfd = gdb_bfd_fopen (filename, gnutarget,
 321                             write_files ? FOPEN_RUB : FOPEN_RB,
 322                             scratch_chan);
 323   if (temp_bfd == NULL)
 324     perror_with_name (filename);
 325
 326   if (!bfd_check_format (temp_bfd, bfd_core)
 327       && !gdb_check_format (temp_bfd))
 328     {
 329       /* Do it after the err msg */
 330       /* FIXME: should be checking for errors from bfd_close (for one
 331          thing, on error it does not free all the storage associated
 332          with the bfd).  */
 333       make_cleanup_bfd_unref (temp_bfd);
 334       error (_("\"%s\" is not a core dump: %s"),
 335              filename, bfd_errmsg (bfd_get_error ()));
 336     }
 337
 338   /* Looks semi-reasonable.  Toss the old core file and work on the
 339      new.  */
 340
 341   do_cleanups (old_chain);
 342   unpush_target (&core_ops);
 343   core_bfd = temp_bfd;
 344   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 345
 346   core_gdbarch = gdbarch_from_bfd (core_bfd);
 347
 348   /* Find a suitable core file handler to munch on core_bfd */
 349   core_vec = sniff_core_bfd (core_bfd);
 350
 351   validate_files ();
 352
 353   core_data = XZALLOC (struct target_section_table);
 354
 355   /* Find the data section */
 356   if (build_section_table (core_bfd,
 357                            &core_data->sections,
 358                            &core_data->sections_end))
 359     error (_("\"%s\": Can't find sections: %s"),
 360            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 361
 362   /* If we have no exec file, try to set the architecture from the
 363      core file.  We don't do this unconditionally since an exec file
 364      typically contains more information that helps us determine the
 365      architecture than a core file.  */
 366   if (!exec_bfd)
 367     set_gdbarch_from_file (core_bfd);
 368
 369   push_target (&core_ops);
 370   discard_cleanups (old_chain);
 371
 372   /* Do this before acknowledging the inferior, so if
 373      post_create_inferior throws (can happen easilly if you're loading
 374      a core file with the wrong exec), we aren't left with threads
 375      from the previous inferior.  */
 376   init_thread_list ();
 377
 378   inferior_ptid = null_ptid;
 379
 380   /* Need to flush the register cache (and the frame cache) from a
 381      previous debug session.  If inferior_ptid ends up the same as the
 382      last debug session --- e.g., b foo; run; gcore core1; step; gcore
 383      core2; core core1; core core2 --- then there's potential for
 384      get_current_regcache to return the cached regcache of the
 385      previous session, and the frame cache being stale.  */
 386   registers_changed ();
 387
 388   /* Build up thread list from BFD sections, and possibly set the
 389      current thread to the .reg/NN section matching the .reg
 390      section.  */
 391   bfd_map_over_sections (core_bfd, add_to_thread_list,
 392                          bfd_get_section_by_name (core_bfd, ".reg"));
 393
 394   if (ptid_equal (inferior_ptid, null_ptid))
 395     {
 396       /* Either we found no .reg/NN section, and hence we have a
 397          non-threaded core (single-threaded, from gdb's perspective),
 398          or for some reason add_to_thread_list couldn't determine
 399          which was the "main" thread.  The latter case shouldn't
 400          usually happen, but we're dealing with input here, which can
 401          always be broken in different ways.  */
 402       struct thread_info *thread = first_thread_of_process (-1);
 403
 404       if (thread == NULL)
 405         {
 406           inferior_appeared (current_inferior (), CORELOW_PID);
 407           inferior_ptid = pid_to_ptid (CORELOW_PID);
 408           add_thread_silent (inferior_ptid);
 409         }
 410       else
 411         switch_to_thread (thread->ptid);
 412     }
 413
 414   post_create_inferior (&core_ops, from_tty);
 415
 416   /* Now go through the target stack looking for threads since there
 417      may be a thread_stratum target loaded on top of target core by
 418      now.  The layer above should claim threads found in the BFD
 419      sections.  */
 420   TRY_CATCH (except, RETURN_MASK_ERROR)
 421     {
 422       target_find_new_threads ();
 423     }
 424
 425   if (except.reason < 0)
 426     exception_print (gdb_stderr, except);
 427
 428   p = bfd_core_file_failing_command (core_bfd);
 429   if (p)
 430     printf_filtered (_("Core was generated by `%s'.\n"), p);
 431
 432   siggy = bfd_core_file_failing_signal (core_bfd);
 433   if (siggy > 0)
 434     {
 435       /* If we don't have a CORE_GDBARCH to work with, assume a native
 436          core (map gdb_signal from host signals).  If we do have
 437          CORE_GDBARCH to work with, but no gdb_signal_from_target
 438          implementation for that gdbarch, as a fallback measure,
 439          assume the host signal mapping.  It'll be correct for native
 440          cores, but most likely incorrect for cross-cores.  */
 441       enum gdb_signal sig = (core_gdbarch != NULL
 442                              && gdbarch_gdb_signal_from_target_p (core_gdbarch)
 443                              ? gdbarch_gdb_signal_from_target (core_gdbarch,
 444                                                                siggy)
 445                              : gdb_signal_from_host (siggy));
 446
 447       printf_filtered (_("Program terminated with signal %d, %s.\n"),
 448                        siggy, gdb_signal_to_string (sig));
 449     }
 450
 451   /* Fetch all registers from core file.  */
 452   target_fetch_registers (get_current_regcache (), -1);
 453
 454   /* Now, set up the frame cache, and print the top of stack.  */
 455   reinit_frame_cache ();
 456   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 457 }
 458
 459 static void
 460 core_detach (struct target_ops *ops, char *args, int from_tty)
 461 {
 462   if (args)
 463     error (_("Too many arguments"));
 464   unpush_target (ops);
 465   reinit_frame_cache ();
 466   if (from_tty)
 467     printf_filtered (_("No core file now.\n"));
 468 }
 469
 470 #ifdef DEPRECATED_IBM6000_TARGET
 471
 472 /* Resize the core memory's section table, by NUM_ADDED.  Returns a
 473    pointer into the first new slot.  This will not be necessary when
 474    the rs6000 target is converted to use the standard solib
 475    framework.  */
 476
 477 struct target_section *
 478 deprecated_core_resize_section_table (int num_added)
 479 {
 480   int old_count;
 481
 482   old_count = resize_section_table (core_data, num_added);
 483   return core_data->sections + old_count;
 484 }
 485
 486 #endif
 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 inferior_ptid's lwp member is zero, do the single-threaded
 493    thing: look for a section named NAME.  If inferior_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 inferior_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 char *name,
 508                            int which,
 509                            const char *human_name,
 510                            int required)
 511 {
 512   static char *section_name = NULL;
 513   struct bfd_section *section;
 514   bfd_size_type size;
 515   char *contents;
 516
 517   xfree (section_name);
 518
 519   if (ptid_get_lwp (inferior_ptid))
 520     section_name = xstrprintf ("%s/%ld", name,
 521                                ptid_get_lwp (inferior_ptid));
 522   else
 523     section_name = xstrdup (name);
 524
 525   section = bfd_get_section_by_name (core_bfd, section_name);
 526   if (! section)
 527     {
 528       if (required)
 529         warning (_("Couldn't find %s registers in core file."),
 530                  human_name);
 531       return;
 532     }
 533
 534   size = bfd_section_size (core_bfd, section);
 535   contents = alloca (size);
 536   if (! bfd_get_section_contents (core_bfd, section, contents,
 537                                   (file_ptr) 0, size))
 538     {
 539       warning (_("Couldn't read %s registers from `%s' section in core file."),
 540                human_name, name);
 541       return;
 542     }
 543
 544   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 545     {
 546       const struct regset *regset;
 547
 548       regset = gdbarch_regset_from_core_section (core_gdbarch,
 549                                                  name, size);
 550       if (regset == NULL)
 551         {
 552           if (required)
 553             warning (_("Couldn't recognize %s registers in core file."),
 554                      human_name);
 555           return;
 556         }
 557
 558       regset->supply_regset (regset, regcache, -1, contents, size);
 559       return;
 560     }
 561
 562   gdb_assert (core_vec);
 563   core_vec->core_read_registers (regcache, contents, size, which,
 564                                  ((CORE_ADDR)
 565                                   bfd_section_vma (core_bfd, section)));
 566 }
 567
 568
 569 /* Get the registers out of a core file.  This is the machine-
 570    independent part.  Fetch_core_registers is the machine-dependent
 571    part, typically implemented in the xm-file for each
 572    architecture.  */
 573
 574 /* We just get all the registers, so we don't use regno.  */
 575
 576 static void
 577 get_core_registers (struct target_ops *ops,
 578                     struct regcache *regcache, int regno)
 579 {
 580   struct core_regset_section *sect_list;
 581   int i;
 582
 583   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 584       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 585     {
 586       fprintf_filtered (gdb_stderr,
 587                      "Can't fetch registers from this type of core file\n");
 588       return;
 589     }
 590
 591   sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache));
 592   if (sect_list)
 593     while (sect_list->sect_name != NULL)
 594       {
 595         if (strcmp (sect_list->sect_name, ".reg") == 0)
 596           get_core_register_section (regcache, sect_list->sect_name,
 597                                      0, sect_list->human_name, 1);
 598         else if (strcmp (sect_list->sect_name, ".reg2") == 0)
 599           get_core_register_section (regcache, sect_list->sect_name,
 600                                      2, sect_list->human_name, 0);
 601         else
 602           get_core_register_section (regcache, sect_list->sect_name,
 603                                      3, sect_list->human_name, 0);
 604
 605         sect_list++;
 606       }
 607
 608   else
 609     {
 610       get_core_register_section (regcache,
 611                                  ".reg", 0, "general-purpose", 1);
 612       get_core_register_section (regcache,
 613                                  ".reg2", 2, "floating-point", 0);
 614     }
 615
 616   /* Mark all registers not found in the core as unavailable.  */
 617   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 618     if (regcache_register_status (regcache, i) == REG_UNKNOWN)
 619       regcache_raw_supply (regcache, i, NULL);
 620 }
 621
 622 static void
 623 core_files_info (struct target_ops *t)
 624 {
 625   print_section_info (core_data, core_bfd);
 626 }
 627 \f
 628 struct spuid_list
 629 {
 630   gdb_byte *buf;
 631   ULONGEST offset;
 632   LONGEST len;
 633   ULONGEST pos;
 634   ULONGEST written;
 635 };
 636
 637 static void
 638 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
 639 {
 640   struct spuid_list *list = list_p;
 641   enum bfd_endian byte_order
 642     = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 643   int fd, pos = 0;
 644
 645   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
 646   if (pos == 0)
 647     return;
 648
 649   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
 650     {
 651       store_unsigned_integer (list->buf + list->pos - list->offset,
 652                               4, byte_order, fd);
 653       list->written += 4;
 654     }
 655   list->pos += 4;
 656 }
 657
 658 /* Read siginfo data from the core, if possible.  Returns -1 on
 659    failure.  Otherwise, returns the number of bytes read.  ABFD is the
 660    core file's BFD; READBUF, OFFSET, and LEN are all as specified by
 661    the to_xfer_partial interface.  */
 662
 663 static LONGEST
 664 get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
 665 {
 666   asection *section;
 667   long pid;
 668   char *section_name;
 669   const char *name = ".note.linuxcore.siginfo";
 670
 671   if (ptid_get_lwp (inferior_ptid))
 672     section_name = xstrprintf ("%s/%ld", name,
 673                                ptid_get_lwp (inferior_ptid));
 674   else
 675     section_name = xstrdup (name);
 676
 677   section = bfd_get_section_by_name (abfd, section_name);
 678   xfree (section_name);
 679   if (section == NULL)
 680     return -1;
 681
 682   if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
 683     return -1;
 684
 685   return len;
 686 }
 687
 688 static LONGEST
 689 core_xfer_partial (struct target_ops *ops, enum target_object object,
 690                    const char *annex, gdb_byte *readbuf,
 691                    const gdb_byte *writebuf, ULONGEST offset,
 692                    LONGEST len)
 693 {
 694   switch (object)
 695     {
 696     case TARGET_OBJECT_MEMORY:
 697       return section_table_xfer_memory_partial (readbuf, writebuf,
 698                                                 offset, len,
 699                                                 core_data->sections,
 700                                                 core_data->sections_end,
 701                                                 NULL);
 702
 703     case TARGET_OBJECT_AUXV:
 704       if (readbuf)
 705         {
 706           /* When the aux vector is stored in core file, BFD
 707              represents this with a fake section called ".auxv".  */
 708
 709           struct bfd_section *section;
 710           bfd_size_type size;
 711
 712           section = bfd_get_section_by_name (core_bfd, ".auxv");
 713           if (section == NULL)
 714             return -1;
 715
 716           size = bfd_section_size (core_bfd, section);
 717           if (offset >= size)
 718             return 0;
 719           size -= offset;
 720           if (size > len)
 721             size = len;
 722           if (size > 0
 723               && !bfd_get_section_contents (core_bfd, section, readbuf,
 724                                             (file_ptr) offset, size))
 725             {
 726               warning (_("Couldn't read NT_AUXV note in core file."));
 727               return -1;
 728             }
 729
 730           return size;
 731         }
 732       return -1;
 733
 734     case TARGET_OBJECT_WCOOKIE:
 735       if (readbuf)
 736         {
 737           /* When the StackGhost cookie is stored in core file, BFD
 738              represents this with a fake section called
 739              ".wcookie".  */
 740
 741           struct bfd_section *section;
 742           bfd_size_type size;
 743
 744           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 745           if (section == NULL)
 746             return -1;
 747
 748           size = bfd_section_size (core_bfd, section);
 749           if (offset >= size)
 750             return 0;
 751           size -= offset;
 752           if (size > len)
 753             size = len;
 754           if (size > 0
 755               && !bfd_get_section_contents (core_bfd, section, readbuf,
 756                                             (file_ptr) offset, size))
 757             {
 758               warning (_("Couldn't read StackGhost cookie in core file."));
 759               return -1;
 760             }
 761
 762           return size;
 763         }
 764       return -1;
 765
 766     case TARGET_OBJECT_LIBRARIES:
 767       if (core_gdbarch
 768           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 769         {
 770           if (writebuf)
 771             return -1;
 772           return
 773             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 774                                                 readbuf, offset, len);
 775         }
 776       /* FALL THROUGH */
 777
 778     case TARGET_OBJECT_SPU:
 779       if (readbuf && annex)
 780         {
 781           /* When the SPU contexts are stored in a core file, BFD
 782              represents this with a fake section called
 783              "SPU/<annex>".  */
 784
 785           struct bfd_section *section;
 786           bfd_size_type size;
 787           char sectionstr[100];
 788
 789           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
 790
 791           section = bfd_get_section_by_name (core_bfd, sectionstr);
 792           if (section == NULL)
 793             return -1;
 794
 795           size = bfd_section_size (core_bfd, section);
 796           if (offset >= size)
 797             return 0;
 798           size -= offset;
 799           if (size > len)
 800             size = len;
 801           if (size > 0
 802               && !bfd_get_section_contents (core_bfd, section, readbuf,
 803                                             (file_ptr) offset, size))
 804             {
 805               warning (_("Couldn't read SPU section in core file."));
 806               return -1;
 807             }
 808
 809           return size;
 810         }
 811       else if (readbuf)
 812         {
 813           /* NULL annex requests list of all present spuids.  */
 814           struct spuid_list list;
 815
 816           list.buf = readbuf;
 817           list.offset = offset;
 818           list.len = len;
 819           list.pos = 0;
 820           list.written = 0;
 821           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
 822           return list.written;
 823         }
 824       return -1;
 825
 826     case TARGET_OBJECT_SIGNAL_INFO:
 827       if (readbuf)
 828         return get_core_siginfo (core_bfd, readbuf, offset, len);
 829       return -1;
 830
 831     default:
 832       if (ops->beneath != NULL)
 833         return ops->beneath->to_xfer_partial (ops->beneath, object,
 834                                               annex, readbuf,
 835                                               writebuf, offset, len);
 836       return -1;
 837     }
 838 }
 839
 840 \f
 841 /* If mourn is being called in all the right places, this could be say
 842    `gdb internal error' (since generic_mourn calls
 843    breakpoint_init_inferior).  */
 844
 845 static int
 846 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
 847 {
 848   return 0;
 849 }
 850
 851
 852 /* Okay, let's be honest: threads gleaned from a core file aren't
 853    exactly lively, are they?  On the other hand, if we don't claim
 854    that each & every one is alive, then we don't get any of them
 855    to appear in an "info thread" command, which is quite a useful
 856    behaviour.
 857  */
 858 static int
 859 core_thread_alive (struct target_ops *ops, ptid_t ptid)
 860 {
 861   return 1;
 862 }
 863
 864 /* Ask the current architecture what it knows about this core file.
 865    That will be used, in turn, to pick a better architecture.  This
 866    wrapper could be avoided if targets got a chance to specialize
 867    core_ops.  */
 868
 869 static const struct target_desc *
 870 core_read_description (struct target_ops *target)
 871 {
 872   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
 873     return gdbarch_core_read_description (core_gdbarch,
 874                                           target, core_bfd);
 875
 876   return NULL;
 877 }
 878
 879 static char *
 880 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
 881 {
 882   static char buf[64];
 883   struct inferior *inf;
 884   int pid;
 885
 886   /* The preferred way is to have a gdbarch/OS specific
 887      implementation.  */
 888   if (core_gdbarch
 889       && gdbarch_core_pid_to_str_p (core_gdbarch))
 890     return gdbarch_core_pid_to_str (core_gdbarch, ptid);
 891
 892   /* Otherwise, if we don't have one, we'll just fallback to
 893      "process", with normal_pid_to_str.  */
 894
 895   /* Try the LWPID field first.  */
 896   pid = ptid_get_lwp (ptid);
 897   if (pid != 0)
 898     return normal_pid_to_str (pid_to_ptid (pid));
 899
 900   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
 901      only if it isn't a fake PID.  */
 902   inf = find_inferior_pid (ptid_get_pid (ptid));
 903   if (inf != NULL && !inf->fake_pid_p)
 904     return normal_pid_to_str (ptid);
 905
 906   /* No luck.  We simply don't have a valid PID to print.  */
 907   xsnprintf (buf, sizeof buf, "<main task>");
 908   return buf;
 909 }
 910
 911 static int
 912 core_has_memory (struct target_ops *ops)
 913 {
 914   return (core_bfd != NULL);
 915 }
 916
 917 static int
 918 core_has_stack (struct target_ops *ops)
 919 {
 920   return (core_bfd != NULL);
 921 }
 922
 923 static int
 924 core_has_registers (struct target_ops *ops)
 925 {
 926   return (core_bfd != NULL);
 927 }
 928
 929 /* Implement the to_info_proc method.  */
 930
 931 static void
 932 core_info_proc (struct target_ops *ops, char *args, enum info_proc_what request)
 933 {
 934   struct gdbarch *gdbarch = get_current_arch ();
 935
 936   /* Since this is the core file target, call the 'core_info_proc'
 937      method on gdbarch, not 'info_proc'.  */
 938   if (gdbarch_core_info_proc_p (gdbarch))
 939     gdbarch_core_info_proc (gdbarch, args, request);
 940 }
 941
 942 /* Fill in core_ops with its defined operations and properties.  */
 943
 944 static void
 945 init_core_ops (void)
 946 {
 947   core_ops.to_shortname = "core";
 948   core_ops.to_longname = "Local core dump file";
 949   core_ops.to_doc =
 950     "Use a core file as a target.  Specify the filename of the core file.";
 951   core_ops.to_open = core_open;
 952   core_ops.to_close = core_close;
 953   core_ops.to_attach = find_default_attach;
 954   core_ops.to_detach = core_detach;
 955   core_ops.to_fetch_registers = get_core_registers;
 956   core_ops.to_xfer_partial = core_xfer_partial;
 957   core_ops.to_files_info = core_files_info;
 958   core_ops.to_insert_breakpoint = ignore;
 959   core_ops.to_remove_breakpoint = ignore;
 960   core_ops.to_create_inferior = find_default_create_inferior;
 961   core_ops.to_thread_alive = core_thread_alive;
 962   core_ops.to_read_description = core_read_description;
 963   core_ops.to_pid_to_str = core_pid_to_str;
 964   core_ops.to_stratum = process_stratum;
 965   core_ops.to_has_memory = core_has_memory;
 966   core_ops.to_has_stack = core_has_stack;
 967   core_ops.to_has_registers = core_has_registers;
 968   core_ops.to_info_proc = core_info_proc;
 969   core_ops.to_magic = OPS_MAGIC;
 970
 971   if (core_target)
 972     internal_error (__FILE__, __LINE__,
 973                     _("init_core_ops: core target already exists (\"%s\")."),
 974                     core_target->to_longname);
 975   core_target = &core_ops;
 976 }
 977
 978 void
 979 _initialize_corelow (void)
 980 {
 981   init_core_ops ();
 982
 983   add_target (&core_ops);
 984 }