gdb/corelow.c

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