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   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 (0/*ignored*/);
 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 = open (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 = XZALLOC (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   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 %d, %s.\n"),
 446                        siggy, gdb_signal_to_string (sig));
 447     }
 448
 449   /* Fetch all registers from core file.  */
 450   target_fetch_registers (get_current_regcache (), -1);
 451
 452   /* Now, set up the frame cache, and print the top of stack.  */
 453   reinit_frame_cache ();
 454   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
 455 }
 456
 457 static void
 458 core_detach (struct target_ops *ops, char *args, int from_tty)
 459 {
 460   if (args)
 461     error (_("Too many arguments"));
 462   unpush_target (ops);
 463   reinit_frame_cache ();
 464   if (from_tty)
 465     printf_filtered (_("No core file now.\n"));
 466 }
 467
 468 #ifdef DEPRECATED_IBM6000_TARGET
 469
 470 /* Resize the core memory's section table, by NUM_ADDED.  Returns a
 471    pointer into the first new slot.  This will not be necessary when
 472    the rs6000 target is converted to use the standard solib
 473    framework.  */
 474
 475 struct target_section *
 476 deprecated_core_resize_section_table (int num_added)
 477 {
 478   int old_count;
 479
 480   old_count = resize_section_table (core_data, num_added);
 481   return core_data->sections + old_count;
 482 }
 483
 484 #endif
 485
 486 /* Try to retrieve registers from a section in core_bfd, and supply
 487    them to core_vec->core_read_registers, as the register set numbered
 488    WHICH.
 489
 490    If inferior_ptid's lwp member is zero, do the single-threaded
 491    thing: look for a section named NAME.  If inferior_ptid's lwp
 492    member is non-zero, do the multi-threaded thing: look for a section
 493    named "NAME/LWP", where LWP is the shortest ASCII decimal
 494    representation of inferior_ptid's lwp member.
 495
 496    HUMAN_NAME is a human-readable name for the kind of registers the
 497    NAME section contains, for use in error messages.
 498
 499    If REQUIRED is non-zero, print an error if the core file doesn't
 500    have a section by the appropriate name.  Otherwise, just do
 501    nothing.  */
 502
 503 static void
 504 get_core_register_section (struct regcache *regcache,
 505                            const char *name,
 506                            int which,
 507                            const char *human_name,
 508                            int required)
 509 {
 510   static char *section_name = NULL;
 511   struct bfd_section *section;
 512   bfd_size_type size;
 513   char *contents;
 514
 515   xfree (section_name);
 516
 517   if (ptid_get_lwp (inferior_ptid))
 518     section_name = xstrprintf ("%s/%ld", name,
 519                                ptid_get_lwp (inferior_ptid));
 520   else
 521     section_name = xstrdup (name);
 522
 523   section = bfd_get_section_by_name (core_bfd, section_name);
 524   if (! section)
 525     {
 526       if (required)
 527         warning (_("Couldn't find %s registers in core file."),
 528                  human_name);
 529       return;
 530     }
 531
 532   size = bfd_section_size (core_bfd, section);
 533   contents = alloca (size);
 534   if (! bfd_get_section_contents (core_bfd, section, contents,
 535                                   (file_ptr) 0, size))
 536     {
 537       warning (_("Couldn't read %s registers from `%s' section in core file."),
 538                human_name, name);
 539       return;
 540     }
 541
 542   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 543     {
 544       const struct regset *regset;
 545
 546       regset = gdbarch_regset_from_core_section (core_gdbarch,
 547                                                  name, size);
 548       if (regset == NULL)
 549         {
 550           if (required)
 551             warning (_("Couldn't recognize %s registers in core file."),
 552                      human_name);
 553           return;
 554         }
 555
 556       regset->supply_regset (regset, regcache, -1, contents, size);
 557       return;
 558     }
 559
 560   gdb_assert (core_vec);
 561   core_vec->core_read_registers (regcache, contents, size, which,
 562                                  ((CORE_ADDR)
 563                                   bfd_section_vma (core_bfd, section)));
 564 }
 565
 566
 567 /* Get the registers out of a core file.  This is the machine-
 568    independent part.  Fetch_core_registers is the machine-dependent
 569    part, typically implemented in the xm-file for each
 570    architecture.  */
 571
 572 /* We just get all the registers, so we don't use regno.  */
 573
 574 static void
 575 get_core_registers (struct target_ops *ops,
 576                     struct regcache *regcache, int regno)
 577 {
 578   struct core_regset_section *sect_list;
 579   int i;
 580
 581   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
 582       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 583     {
 584       fprintf_filtered (gdb_stderr,
 585                      "Can't fetch registers from this type of core file\n");
 586       return;
 587     }
 588
 589   sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache));
 590   if (sect_list)
 591     while (sect_list->sect_name != NULL)
 592       {
 593         if (strcmp (sect_list->sect_name, ".reg") == 0)
 594           get_core_register_section (regcache, sect_list->sect_name,
 595                                      0, sect_list->human_name, 1);
 596         else if (strcmp (sect_list->sect_name, ".reg2") == 0)
 597           get_core_register_section (regcache, sect_list->sect_name,
 598                                      2, sect_list->human_name, 0);
 599         else
 600           get_core_register_section (regcache, sect_list->sect_name,
 601                                      3, sect_list->human_name, 0);
 602
 603         sect_list++;
 604       }
 605
 606   else
 607     {
 608       get_core_register_section (regcache,
 609                                  ".reg", 0, "general-purpose", 1);
 610       get_core_register_section (regcache,
 611                                  ".reg2", 2, "floating-point", 0);
 612     }
 613
 614   /* Mark all registers not found in the core as unavailable.  */
 615   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 616     if (regcache_register_status (regcache, i) == REG_UNKNOWN)
 617       regcache_raw_supply (regcache, i, NULL);
 618 }
 619
 620 static void
 621 core_files_info (struct target_ops *t)
 622 {
 623   print_section_info (core_data, core_bfd);
 624 }
 625 \f
 626 struct spuid_list
 627 {
 628   gdb_byte *buf;
 629   ULONGEST offset;
 630   LONGEST len;
 631   ULONGEST pos;
 632   ULONGEST written;
 633 };
 634
 635 static void
 636 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
 637 {
 638   struct spuid_list *list = list_p;
 639   enum bfd_endian byte_order
 640     = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 641   int fd, pos = 0;
 642
 643   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
 644   if (pos == 0)
 645     return;
 646
 647   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
 648     {
 649       store_unsigned_integer (list->buf + list->pos - list->offset,
 650                               4, byte_order, fd);
 651       list->written += 4;
 652     }
 653   list->pos += 4;
 654 }
 655
 656 /* Read siginfo data from the core, if possible.  Returns -1 on
 657    failure.  Otherwise, returns the number of bytes read.  ABFD is the
 658    core file's BFD; READBUF, OFFSET, and LEN are all as specified by
 659    the to_xfer_partial interface.  */
 660
 661 static LONGEST
 662 get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
 663 {
 664   asection *section;
 665   char *section_name;
 666   const char *name = ".note.linuxcore.siginfo";
 667
 668   if (ptid_get_lwp (inferior_ptid))
 669     section_name = xstrprintf ("%s/%ld", name,
 670                                ptid_get_lwp (inferior_ptid));
 671   else
 672     section_name = xstrdup (name);
 673
 674   section = bfd_get_section_by_name (abfd, section_name);
 675   xfree (section_name);
 676   if (section == NULL)
 677     return -1;
 678
 679   if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
 680     return -1;
 681
 682   return len;
 683 }
 684
 685 static LONGEST
 686 core_xfer_partial (struct target_ops *ops, enum target_object object,
 687                    const char *annex, gdb_byte *readbuf,
 688                    const gdb_byte *writebuf, ULONGEST offset,
 689                    LONGEST len)
 690 {
 691   switch (object)
 692     {
 693     case TARGET_OBJECT_MEMORY:
 694       return section_table_xfer_memory_partial (readbuf, writebuf,
 695                                                 offset, len,
 696                                                 core_data->sections,
 697                                                 core_data->sections_end,
 698                                                 NULL);
 699
 700     case TARGET_OBJECT_AUXV:
 701       if (readbuf)
 702         {
 703           /* When the aux vector is stored in core file, BFD
 704              represents this with a fake section called ".auxv".  */
 705
 706           struct bfd_section *section;
 707           bfd_size_type size;
 708
 709           section = bfd_get_section_by_name (core_bfd, ".auxv");
 710           if (section == NULL)
 711             return -1;
 712
 713           size = bfd_section_size (core_bfd, section);
 714           if (offset >= size)
 715             return 0;
 716           size -= offset;
 717           if (size > len)
 718             size = len;
 719           if (size > 0
 720               && !bfd_get_section_contents (core_bfd, section, readbuf,
 721                                             (file_ptr) offset, size))
 722             {
 723               warning (_("Couldn't read NT_AUXV note in core file."));
 724               return -1;
 725             }
 726
 727           return size;
 728         }
 729       return -1;
 730
 731     case TARGET_OBJECT_WCOOKIE:
 732       if (readbuf)
 733         {
 734           /* When the StackGhost cookie is stored in core file, BFD
 735              represents this with a fake section called
 736              ".wcookie".  */
 737
 738           struct bfd_section *section;
 739           bfd_size_type size;
 740
 741           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 742           if (section == NULL)
 743             return -1;
 744
 745           size = bfd_section_size (core_bfd, section);
 746           if (offset >= size)
 747             return 0;
 748           size -= offset;
 749           if (size > len)
 750             size = len;
 751           if (size > 0
 752               && !bfd_get_section_contents (core_bfd, section, readbuf,
 753                                             (file_ptr) offset, size))
 754             {
 755               warning (_("Couldn't read StackGhost cookie in core file."));
 756               return -1;
 757             }
 758
 759           return size;
 760         }
 761       return -1;
 762
 763     case TARGET_OBJECT_LIBRARIES:
 764       if (core_gdbarch
 765           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 766         {
 767           if (writebuf)
 768             return -1;
 769           return
 770             gdbarch_core_xfer_shared_libraries (core_gdbarch,
 771                                                 readbuf, offset, len);
 772         }
 773       /* FALL THROUGH */
 774
 775     case TARGET_OBJECT_SPU:
 776       if (readbuf && annex)
 777         {
 778           /* When the SPU contexts are stored in a core file, BFD
 779              represents this with a fake section called
 780              "SPU/<annex>".  */
 781
 782           struct bfd_section *section;
 783           bfd_size_type size;
 784           char sectionstr[100];
 785
 786           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
 787
 788           section = bfd_get_section_by_name (core_bfd, sectionstr);
 789           if (section == NULL)
 790             return -1;
 791
 792           size = bfd_section_size (core_bfd, section);
 793           if (offset >= size)
 794             return 0;
 795           size -= offset;
 796           if (size > len)
 797             size = len;
 798           if (size > 0
 799               && !bfd_get_section_contents (core_bfd, section, readbuf,
 800                                             (file_ptr) offset, size))
 801             {
 802               warning (_("Couldn't read SPU section in core file."));
 803               return -1;
 804             }
 805
 806           return size;
 807         }
 808       else if (readbuf)
 809         {
 810           /* NULL annex requests list of all present spuids.  */
 811           struct spuid_list list;
 812
 813           list.buf = readbuf;
 814           list.offset = offset;
 815           list.len = len;
 816           list.pos = 0;
 817           list.written = 0;
 818           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
 819           return list.written;
 820         }
 821       return -1;
 822
 823     case TARGET_OBJECT_SIGNAL_INFO:
 824       if (readbuf)
 825         return get_core_siginfo (core_bfd, readbuf, offset, len);
 826       return -1;
 827
 828     default:
 829       if (ops->beneath != NULL)
 830         return ops->beneath->to_xfer_partial (ops->beneath, object,
 831                                               annex, readbuf,
 832                                               writebuf, offset, len);
 833       return -1;
 834     }
 835 }
 836
 837 \f
 838 /* If mourn is being called in all the right places, this could be say
 839    `gdb internal error' (since generic_mourn calls
 840    breakpoint_init_inferior).  */
 841
 842 static int
 843 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
 844 {
 845   return 0;
 846 }
 847
 848
 849 /* Okay, let's be honest: threads gleaned from a core file aren't
 850    exactly lively, are they?  On the other hand, if we don't claim
 851    that each & every one is alive, then we don't get any of them
 852    to appear in an "info thread" command, which is quite a useful
 853    behaviour.
 854  */
 855 static int
 856 core_thread_alive (struct target_ops *ops, ptid_t ptid)
 857 {
 858   return 1;
 859 }
 860
 861 /* Ask the current architecture what it knows about this core file.
 862    That will be used, in turn, to pick a better architecture.  This
 863    wrapper could be avoided if targets got a chance to specialize
 864    core_ops.  */
 865
 866 static const struct target_desc *
 867 core_read_description (struct target_ops *target)
 868 {
 869   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
 870     return gdbarch_core_read_description (core_gdbarch,
 871                                           target, core_bfd);
 872
 873   return NULL;
 874 }
 875
 876 static char *
 877 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
 878 {
 879   static char buf[64];
 880   struct inferior *inf;
 881   int pid;
 882
 883   /* The preferred way is to have a gdbarch/OS specific
 884      implementation.  */
 885   if (core_gdbarch
 886       && gdbarch_core_pid_to_str_p (core_gdbarch))
 887     return gdbarch_core_pid_to_str (core_gdbarch, ptid);
 888
 889   /* Otherwise, if we don't have one, we'll just fallback to
 890      "process", with normal_pid_to_str.  */
 891
 892   /* Try the LWPID field first.  */
 893   pid = ptid_get_lwp (ptid);
 894   if (pid != 0)
 895     return normal_pid_to_str (pid_to_ptid (pid));
 896
 897   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
 898      only if it isn't a fake PID.  */
 899   inf = find_inferior_pid (ptid_get_pid (ptid));
 900   if (inf != NULL && !inf->fake_pid_p)
 901     return normal_pid_to_str (ptid);
 902
 903   /* No luck.  We simply don't have a valid PID to print.  */
 904   xsnprintf (buf, sizeof buf, "<main task>");
 905   return buf;
 906 }
 907
 908 static int
 909 core_has_memory (struct target_ops *ops)
 910 {
 911   return (core_bfd != NULL);
 912 }
 913
 914 static int
 915 core_has_stack (struct target_ops *ops)
 916 {
 917   return (core_bfd != NULL);
 918 }
 919
 920 static int
 921 core_has_registers (struct target_ops *ops)
 922 {
 923   return (core_bfd != NULL);
 924 }
 925
 926 /* Implement the to_info_proc method.  */
 927
 928 static void
 929 core_info_proc (struct target_ops *ops, char *args, enum info_proc_what request)
 930 {
 931   struct gdbarch *gdbarch = get_current_arch ();
 932
 933   /* Since this is the core file target, call the 'core_info_proc'
 934      method on gdbarch, not 'info_proc'.  */
 935   if (gdbarch_core_info_proc_p (gdbarch))
 936     gdbarch_core_info_proc (gdbarch, args, request);
 937 }
 938
 939 /* Fill in core_ops with its defined operations and properties.  */
 940
 941 static void
 942 init_core_ops (void)
 943 {
 944   core_ops.to_shortname = "core";
 945   core_ops.to_longname = "Local core dump file";
 946   core_ops.to_doc =
 947     "Use a core file as a target.  Specify the filename of the core file.";
 948   core_ops.to_open = core_open;
 949   core_ops.to_close = core_close;
 950   core_ops.to_attach = find_default_attach;
 951   core_ops.to_detach = core_detach;
 952   core_ops.to_fetch_registers = get_core_registers;
 953   core_ops.to_xfer_partial = core_xfer_partial;
 954   core_ops.to_files_info = core_files_info;
 955   core_ops.to_insert_breakpoint = ignore;
 956   core_ops.to_remove_breakpoint = ignore;
 957   core_ops.to_create_inferior = find_default_create_inferior;
 958   core_ops.to_thread_alive = core_thread_alive;
 959   core_ops.to_read_description = core_read_description;
 960   core_ops.to_pid_to_str = core_pid_to_str;
 961   core_ops.to_stratum = process_stratum;
 962   core_ops.to_has_memory = core_has_memory;
 963   core_ops.to_has_stack = core_has_stack;
 964   core_ops.to_has_registers = core_has_registers;
 965   core_ops.to_info_proc = core_info_proc;
 966   core_ops.to_magic = OPS_MAGIC;
 967
 968   if (core_target)
 969     internal_error (__FILE__, __LINE__,
 970                     _("init_core_ops: core target already exists (\"%s\")."),
 971                     core_target->to_longname);
 972   core_target = &core_ops;
 973 }
 974
 975 void
 976 _initialize_corelow (void)
 977 {
 978   init_core_ops ();
 979
 980   add_target (&core_ops);
 981 }