gdb/corelow.c

   1 /* Core dump and executable file functions below target vector, for GDB.
   2
   3    Copyright (C) 1986-2016 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 (!startswith (bfd_section_name (abfd, asect), ".reg/"))
 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   char *filename;
 282
 283   target_preopen (from_tty);
 284   if (!arg)
 285     {
 286       if (core_bfd)
 287         error (_("No core file specified.  (Use `detach' "
 288                  "to stop debugging a core file.)"));
 289       else
 290         error (_("No core file specified."));
 291     }
 292
 293   filename = tilde_expand (arg);
 294   if (!IS_ABSOLUTE_PATH (filename))
 295     {
 296       temp = concat (current_directory, "/",
 297                      filename, (char *) NULL);
 298       xfree (filename);
 299       filename = temp;
 300     }
 301
 302   old_chain = make_cleanup (xfree, filename);
 303
 304   flags = O_BINARY | O_LARGEFILE;
 305   if (write_files)
 306     flags |= O_RDWR;
 307   else
 308     flags |= O_RDONLY;
 309   scratch_chan = gdb_open_cloexec (filename, flags, 0);
 310   if (scratch_chan < 0)
 311     perror_with_name (filename);
 312
 313   temp_bfd = gdb_bfd_fopen (filename, gnutarget,
 314                             write_files ? FOPEN_RUB : FOPEN_RB,
 315                             scratch_chan);
 316   if (temp_bfd == NULL)
 317     perror_with_name (filename);
 318
 319   if (!bfd_check_format (temp_bfd, bfd_core)
 320       && !gdb_check_format (temp_bfd))
 321     {
 322       /* Do it after the err msg */
 323       /* FIXME: should be checking for errors from bfd_close (for one
 324          thing, on error it does not free all the storage associated
 325          with the bfd).  */
 326       make_cleanup_bfd_unref (temp_bfd);
 327       error (_("\"%s\" is not a core dump: %s"),
 328              filename, bfd_errmsg (bfd_get_error ()));
 329     }
 330
 331   /* Looks semi-reasonable.  Toss the old core file and work on the
 332      new.  */
 333
 334   do_cleanups (old_chain);
 335   unpush_target (&core_ops);
 336   core_bfd = temp_bfd;
 337   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
 338
 339   core_gdbarch = gdbarch_from_bfd (core_bfd);
 340
 341   /* Find a suitable core file handler to munch on core_bfd */
 342   core_vec = sniff_core_bfd (core_bfd);
 343
 344   validate_files ();
 345
 346   core_data = XCNEW (struct target_section_table);
 347
 348   /* Find the data section */
 349   if (build_section_table (core_bfd,
 350                            &core_data->sections,
 351                            &core_data->sections_end))
 352     error (_("\"%s\": Can't find sections: %s"),
 353            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 354
 355   /* If we have no exec file, try to set the architecture from the
 356      core file.  We don't do this unconditionally since an exec file
 357      typically contains more information that helps us determine the
 358      architecture than a core file.  */
 359   if (!exec_bfd)
 360     set_gdbarch_from_file (core_bfd);
 361
 362   push_target (&core_ops);
 363   discard_cleanups (old_chain);
 364
 365   /* Do this before acknowledging the inferior, so if
 366      post_create_inferior throws (can happen easilly if you're loading
 367      a core file with the wrong exec), we aren't left with threads
 368      from the previous inferior.  */
 369   init_thread_list ();
 370
 371   inferior_ptid = null_ptid;
 372
 373   /* Need to flush the register cache (and the frame cache) from a
 374      previous debug session.  If inferior_ptid ends up the same as the
 375      last debug session --- e.g., b foo; run; gcore core1; step; gcore
 376      core2; core core1; core core2 --- then there's potential for
 377      get_current_regcache to return the cached regcache of the
 378      previous session, and the frame cache being stale.  */
 379   registers_changed ();
 380
 381   /* Build up thread list from BFD sections, and possibly set the
 382      current thread to the .reg/NN section matching the .reg
 383      section.  */
 384   bfd_map_over_sections (core_bfd, add_to_thread_list,
 385                          bfd_get_section_by_name (core_bfd, ".reg"));
 386
 387   if (ptid_equal (inferior_ptid, null_ptid))
 388     {
 389       /* Either we found no .reg/NN section, and hence we have a
 390          non-threaded core (single-threaded, from gdb's perspective),
 391          or for some reason add_to_thread_list couldn't determine
 392          which was the "main" thread.  The latter case shouldn't
 393          usually happen, but we're dealing with input here, which can
 394          always be broken in different ways.  */
 395       struct thread_info *thread = first_thread_of_process (-1);
 396
 397       if (thread == NULL)
 398         {
 399           inferior_appeared (current_inferior (), CORELOW_PID);
 400           inferior_ptid = pid_to_ptid (CORELOW_PID);
 401           add_thread_silent (inferior_ptid);
 402         }
 403       else
 404         switch_to_thread (thread->ptid);
 405     }
 406
 407   post_create_inferior (&core_ops, from_tty);
 408
 409   /* Now go through the target stack looking for threads since there
 410      may be a thread_stratum target loaded on top of target core by
 411      now.  The layer above should claim threads found in the BFD
 412      sections.  */
 413   TRY
 414     {
 415       target_update_thread_list ();
 416     }
 417
 418   CATCH (except, RETURN_MASK_ERROR)
 419     {
 420       exception_print (gdb_stderr, except);
 421     }
 422   END_CATCH
 423
 424   p = bfd_core_file_failing_command (core_bfd);
 425   if (p)
 426     printf_filtered (_("Core was generated by `%s'.\n"), p);
 427
 428   /* Clearing any previous state of convenience variables.  */
 429   clear_exit_convenience_vars ();
 430
 431   siggy = bfd_core_file_failing_signal (core_bfd);
 432   if (siggy > 0)
 433     {
 434       /* If we don't have a CORE_GDBARCH to work with, assume a native
 435          core (map gdb_signal from host signals).  If we do have
 436          CORE_GDBARCH to work with, but no gdb_signal_from_target
 437          implementation for that gdbarch, as a fallback measure,
 438          assume the host signal mapping.  It'll be correct for native
 439          cores, but most likely incorrect for cross-cores.  */
 440       enum gdb_signal sig = (core_gdbarch != NULL
 441                              && gdbarch_gdb_signal_from_target_p (core_gdbarch)
 442                              ? gdbarch_gdb_signal_from_target (core_gdbarch,
 443                                                                siggy)
 444                              : gdb_signal_from_host (siggy));
 445
 446       printf_filtered (_("Program terminated with signal %s, %s.\n"),
 447                        gdb_signal_to_name (sig), gdb_signal_to_string (sig));
 448
 449       /* Set the value of the internal variable $_exitsignal,
 450          which holds the signal uncaught by the inferior.  */
 451       set_internalvar_integer (lookup_internalvar ("_exitsignal"),
 452                                siggy);
 453     }
 454
 455   /* Fetch all registers from core file.  */
 456   target_fetch_registers (get_current_regcache (), -1);
 457
 458   /* Now, set up the frame cache, and print the top of stack.  */
 459   reinit_frame_cache ();
 460   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
 461
 462   /* Current thread should be NUM 1 but the user does not know that.
 463      If a program is single threaded gdb in general does not mention
 464      anything about threads.  That is why the test is >= 2.  */
 465   if (thread_count () >= 2)
 466     {
 467       TRY
 468         {
 469           thread_command (NULL, from_tty);
 470         }
 471       CATCH (except, RETURN_MASK_ERROR)
 472         {
 473           exception_print (gdb_stderr, except);
 474         }
 475       END_CATCH
 476     }
 477 }
 478
 479 static void
 480 core_detach (struct target_ops *ops, const char *args, int from_tty)
 481 {
 482   if (args)
 483     error (_("Too many arguments"));
 484   unpush_target (ops);
 485   reinit_frame_cache ();
 486   if (from_tty)
 487     printf_filtered (_("No core file now.\n"));
 488 }
 489
 490 /* Try to retrieve registers from a section in core_bfd, and supply
 491    them to core_vec->core_read_registers, as the register set numbered
 492    WHICH.
 493
 494    If inferior_ptid's lwp member is zero, do the single-threaded
 495    thing: look for a section named NAME.  If inferior_ptid's lwp
 496    member is non-zero, do the multi-threaded thing: look for a section
 497    named "NAME/LWP", where LWP is the shortest ASCII decimal
 498    representation of inferior_ptid's lwp member.
 499
 500    HUMAN_NAME is a human-readable name for the kind of registers the
 501    NAME section contains, for use in error messages.
 502
 503    If REQUIRED is non-zero, print an error if the core file doesn't
 504    have a section by the appropriate name.  Otherwise, just do
 505    nothing.  */
 506
 507 static void
 508 get_core_register_section (struct regcache *regcache,
 509                            const struct regset *regset,
 510                            const char *name,
 511                            int min_size,
 512                            int which,
 513                            const char *human_name,
 514                            int required)
 515 {
 516   static char *section_name = NULL;
 517   struct bfd_section *section;
 518   bfd_size_type size;
 519   char *contents;
 520
 521   xfree (section_name);
 522
 523   if (ptid_get_lwp (inferior_ptid))
 524     section_name = xstrprintf ("%s/%ld", name,
 525                                ptid_get_lwp (inferior_ptid));
 526   else
 527     section_name = xstrdup (name);
 528
 529   section = bfd_get_section_by_name (core_bfd, section_name);
 530   if (! section)
 531     {
 532       if (required)
 533         warning (_("Couldn't find %s registers in core file."),
 534                  human_name);
 535       return;
 536     }
 537
 538   size = bfd_section_size (core_bfd, section);
 539   if (size < min_size)
 540     {
 541       warning (_("Section `%s' in core file too small."), section_name);
 542       return;
 543     }
 544   if (size != min_size && !(regset->flags & REGSET_VARIABLE_SIZE))
 545     {
 546       warning (_("Unexpected size of section `%s' in core file."),
 547                section_name);
 548     }
 549
 550   contents = (char *) alloca (size);
 551   if (! bfd_get_section_contents (core_bfd, section, contents,
 552                                   (file_ptr) 0, size))
 553     {
 554       warning (_("Couldn't read %s registers from `%s' section in core file."),
 555                human_name, name);
 556       return;
 557     }
 558
 559   if (regset != NULL)
 560     {
 561       regset->supply_regset (regset, regcache, -1, contents, size);
 562       return;
 563     }
 564
 565   gdb_assert (core_vec);
 566   core_vec->core_read_registers (regcache, contents, size, which,
 567                                  ((CORE_ADDR)
 568                                   bfd_section_vma (core_bfd, section)));
 569 }
 570
 571 /* Callback for get_core_registers that handles a single core file
 572    register note section. */
 573
 574 static void
 575 get_core_registers_cb (const char *sect_name, int size,
 576                        const struct regset *regset,
 577                        const char *human_name, void *cb_data)
 578 {
 579   struct regcache *regcache = (struct regcache *) cb_data;
 580   int required = 0;
 581
 582   if (strcmp (sect_name, ".reg") == 0)
 583     {
 584       required = 1;
 585       if (human_name == NULL)
 586         human_name = "general-purpose";
 587     }
 588   else if (strcmp (sect_name, ".reg2") == 0)
 589     {
 590       if (human_name == NULL)
 591         human_name = "floating-point";
 592     }
 593
 594   /* The 'which' parameter is only used when no regset is provided.
 595      Thus we just set it to -1. */
 596   get_core_register_section (regcache, regset, sect_name,
 597                              size, -1, human_name, required);
 598 }
 599
 600 /* Get the registers out of a core file.  This is the machine-
 601    independent part.  Fetch_core_registers is the machine-dependent
 602    part, typically implemented in the xm-file for each
 603    architecture.  */
 604
 605 /* We just get all the registers, so we don't use regno.  */
 606
 607 static void
 608 get_core_registers (struct target_ops *ops,
 609                     struct regcache *regcache, int regno)
 610 {
 611   int i;
 612   struct gdbarch *gdbarch;
 613
 614   if (!(core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
 615       && (core_vec == NULL || core_vec->core_read_registers == NULL))
 616     {
 617       fprintf_filtered (gdb_stderr,
 618                      "Can't fetch registers from this type of core file\n");
 619       return;
 620     }
 621
 622   gdbarch = get_regcache_arch (regcache);
 623   if (gdbarch_iterate_over_regset_sections_p (gdbarch))
 624     gdbarch_iterate_over_regset_sections (gdbarch,
 625                                           get_core_registers_cb,
 626                                           (void *) regcache, NULL);
 627   else
 628     {
 629       get_core_register_section (regcache, NULL,
 630                                  ".reg", 0, 0, "general-purpose", 1);
 631       get_core_register_section (regcache, NULL,
 632                                  ".reg2", 0, 2, "floating-point", 0);
 633     }
 634
 635   /* Mark all registers not found in the core as unavailable.  */
 636   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 637     if (regcache_register_status (regcache, i) == REG_UNKNOWN)
 638       regcache_raw_supply (regcache, i, NULL);
 639 }
 640
 641 static void
 642 core_files_info (struct target_ops *t)
 643 {
 644   print_section_info (core_data, core_bfd);
 645 }
 646 \f
 647 struct spuid_list
 648 {
 649   gdb_byte *buf;
 650   ULONGEST offset;
 651   LONGEST len;
 652   ULONGEST pos;
 653   ULONGEST written;
 654 };
 655
 656 static void
 657 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
 658 {
 659   struct spuid_list *list = (struct spuid_list *) list_p;
 660   enum bfd_endian byte_order
 661     = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 662   int fd, pos = 0;
 663
 664   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
 665   if (pos == 0)
 666     return;
 667
 668   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
 669     {
 670       store_unsigned_integer (list->buf + list->pos - list->offset,
 671                               4, byte_order, fd);
 672       list->written += 4;
 673     }
 674   list->pos += 4;
 675 }
 676
 677 /* Read siginfo data from the core, if possible.  Returns -1 on
 678    failure.  Otherwise, returns the number of bytes read.  ABFD is the
 679    core file's BFD; READBUF, OFFSET, and LEN are all as specified by
 680    the to_xfer_partial interface.  */
 681
 682 static LONGEST
 683 get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
 684 {
 685   asection *section;
 686   char *section_name;
 687   const char *name = ".note.linuxcore.siginfo";
 688
 689   if (ptid_get_lwp (inferior_ptid))
 690     section_name = xstrprintf ("%s/%ld", name,
 691                                ptid_get_lwp (inferior_ptid));
 692   else
 693     section_name = xstrdup (name);
 694
 695   section = bfd_get_section_by_name (abfd, section_name);
 696   xfree (section_name);
 697   if (section == NULL)
 698     return -1;
 699
 700   if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
 701     return -1;
 702
 703   return len;
 704 }
 705
 706 static enum target_xfer_status
 707 core_xfer_partial (struct target_ops *ops, enum target_object object,
 708                    const char *annex, gdb_byte *readbuf,
 709                    const gdb_byte *writebuf, ULONGEST offset,
 710                    ULONGEST len, ULONGEST *xfered_len)
 711 {
 712   switch (object)
 713     {
 714     case TARGET_OBJECT_MEMORY:
 715       return section_table_xfer_memory_partial (readbuf, writebuf,
 716                                                 offset, len, xfered_len,
 717                                                 core_data->sections,
 718                                                 core_data->sections_end,
 719                                                 NULL);
 720
 721     case TARGET_OBJECT_AUXV:
 722       if (readbuf)
 723         {
 724           /* When the aux vector is stored in core file, BFD
 725              represents this with a fake section called ".auxv".  */
 726
 727           struct bfd_section *section;
 728           bfd_size_type size;
 729
 730           section = bfd_get_section_by_name (core_bfd, ".auxv");
 731           if (section == NULL)
 732             return TARGET_XFER_E_IO;
 733
 734           size = bfd_section_size (core_bfd, section);
 735           if (offset >= size)
 736             return TARGET_XFER_EOF;
 737           size -= offset;
 738           if (size > len)
 739             size = len;
 740
 741           if (size == 0)
 742             return TARGET_XFER_EOF;
 743           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 744                                          (file_ptr) offset, size))
 745             {
 746               warning (_("Couldn't read NT_AUXV note in core file."));
 747               return TARGET_XFER_E_IO;
 748             }
 749
 750           *xfered_len = (ULONGEST) size;
 751           return TARGET_XFER_OK;
 752         }
 753       return TARGET_XFER_E_IO;
 754
 755     case TARGET_OBJECT_WCOOKIE:
 756       if (readbuf)
 757         {
 758           /* When the StackGhost cookie is stored in core file, BFD
 759              represents this with a fake section called
 760              ".wcookie".  */
 761
 762           struct bfd_section *section;
 763           bfd_size_type size;
 764
 765           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 766           if (section == NULL)
 767             return TARGET_XFER_E_IO;
 768
 769           size = bfd_section_size (core_bfd, section);
 770           if (offset >= size)
 771             return TARGET_XFER_EOF;
 772           size -= offset;
 773           if (size > len)
 774             size = len;
 775
 776           if (size == 0)
 777             return TARGET_XFER_EOF;
 778           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 779                                          (file_ptr) offset, size))
 780             {
 781               warning (_("Couldn't read StackGhost cookie in core file."));
 782               return TARGET_XFER_E_IO;
 783             }
 784
 785           *xfered_len = (ULONGEST) size;
 786           return TARGET_XFER_OK;
 787
 788         }
 789       return TARGET_XFER_E_IO;
 790
 791     case TARGET_OBJECT_LIBRARIES:
 792       if (core_gdbarch
 793           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
 794         {
 795           if (writebuf)
 796             return TARGET_XFER_E_IO;
 797           else
 798             {
 799               *xfered_len = gdbarch_core_xfer_shared_libraries (core_gdbarch,
 800                                                                 readbuf,
 801                                                                 offset, len);
 802
 803               if (*xfered_len == 0)
 804                 return TARGET_XFER_EOF;
 805               else
 806                 return TARGET_XFER_OK;
 807             }
 808         }
 809       /* FALL THROUGH */
 810
 811     case TARGET_OBJECT_LIBRARIES_AIX:
 812       if (core_gdbarch
 813           && gdbarch_core_xfer_shared_libraries_aix_p (core_gdbarch))
 814         {
 815           if (writebuf)
 816             return TARGET_XFER_E_IO;
 817           else
 818             {
 819               *xfered_len
 820                 = gdbarch_core_xfer_shared_libraries_aix (core_gdbarch,
 821                                                           readbuf, offset,
 822                                                           len);
 823
 824               if (*xfered_len == 0)
 825                 return TARGET_XFER_EOF;
 826               else
 827                 return TARGET_XFER_OK;
 828             }
 829         }
 830       /* FALL THROUGH */
 831
 832     case TARGET_OBJECT_SPU:
 833       if (readbuf && annex)
 834         {
 835           /* When the SPU contexts are stored in a core file, BFD
 836              represents this with a fake section called
 837              "SPU/<annex>".  */
 838
 839           struct bfd_section *section;
 840           bfd_size_type size;
 841           char sectionstr[100];
 842
 843           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
 844
 845           section = bfd_get_section_by_name (core_bfd, sectionstr);
 846           if (section == NULL)
 847             return TARGET_XFER_E_IO;
 848
 849           size = bfd_section_size (core_bfd, section);
 850           if (offset >= size)
 851             return TARGET_XFER_EOF;
 852           size -= offset;
 853           if (size > len)
 854             size = len;
 855
 856           if (size == 0)
 857             return TARGET_XFER_EOF;
 858           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 859                                          (file_ptr) offset, size))
 860             {
 861               warning (_("Couldn't read SPU section in core file."));
 862               return TARGET_XFER_E_IO;
 863             }
 864
 865           *xfered_len = (ULONGEST) size;
 866           return TARGET_XFER_OK;
 867         }
 868       else if (readbuf)
 869         {
 870           /* NULL annex requests list of all present spuids.  */
 871           struct spuid_list list;
 872
 873           list.buf = readbuf;
 874           list.offset = offset;
 875           list.len = len;
 876           list.pos = 0;
 877           list.written = 0;
 878           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
 879
 880           if (list.written == 0)
 881             return TARGET_XFER_EOF;
 882           else
 883             {
 884               *xfered_len = (ULONGEST) list.written;
 885               return TARGET_XFER_OK;
 886             }
 887         }
 888       return TARGET_XFER_E_IO;
 889
 890     case TARGET_OBJECT_SIGNAL_INFO:
 891       if (readbuf)
 892         {
 893           LONGEST l = get_core_siginfo (core_bfd, readbuf, offset, len);
 894
 895           if (l > 0)
 896             {
 897               *xfered_len = len;
 898               return TARGET_XFER_OK;
 899             }
 900         }
 901       return TARGET_XFER_E_IO;
 902
 903     default:
 904       return ops->beneath->to_xfer_partial (ops->beneath, object,
 905                                             annex, readbuf,
 906                                             writebuf, offset, len,
 907                                             xfered_len);
 908     }
 909 }
 910
 911 \f
 912 /* If mourn is being called in all the right places, this could be say
 913    `gdb internal error' (since generic_mourn calls
 914    breakpoint_init_inferior).  */
 915
 916 static int
 917 ignore (struct target_ops *ops, struct gdbarch *gdbarch,
 918         struct bp_target_info *bp_tgt)
 919 {
 920   return 0;
 921 }
 922
 923
 924 /* Okay, let's be honest: threads gleaned from a core file aren't
 925    exactly lively, are they?  On the other hand, if we don't claim
 926    that each & every one is alive, then we don't get any of them
 927    to appear in an "info thread" command, which is quite a useful
 928    behaviour.
 929  */
 930 static int
 931 core_thread_alive (struct target_ops *ops, ptid_t ptid)
 932 {
 933   return 1;
 934 }
 935
 936 /* Ask the current architecture what it knows about this core file.
 937    That will be used, in turn, to pick a better architecture.  This
 938    wrapper could be avoided if targets got a chance to specialize
 939    core_ops.  */
 940
 941 static const struct target_desc *
 942 core_read_description (struct target_ops *target)
 943 {
 944   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
 945     {
 946       const struct target_desc *result;
 947
 948       result = gdbarch_core_read_description (core_gdbarch,
 949                                               target, core_bfd);
 950       if (result != NULL)
 951         return result;
 952     }
 953
 954   return target->beneath->to_read_description (target->beneath);
 955 }
 956
 957 static char *
 958 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
 959 {
 960   static char buf[64];
 961   struct inferior *inf;
 962   int pid;
 963
 964   /* The preferred way is to have a gdbarch/OS specific
 965      implementation.  */
 966   if (core_gdbarch
 967       && gdbarch_core_pid_to_str_p (core_gdbarch))
 968     return gdbarch_core_pid_to_str (core_gdbarch, ptid);
 969
 970   /* Otherwise, if we don't have one, we'll just fallback to
 971      "process", with normal_pid_to_str.  */
 972
 973   /* Try the LWPID field first.  */
 974   pid = ptid_get_lwp (ptid);
 975   if (pid != 0)
 976     return normal_pid_to_str (pid_to_ptid (pid));
 977
 978   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
 979      only if it isn't a fake PID.  */
 980   inf = find_inferior_ptid (ptid);
 981   if (inf != NULL && !inf->fake_pid_p)
 982     return normal_pid_to_str (ptid);
 983
 984   /* No luck.  We simply don't have a valid PID to print.  */
 985   xsnprintf (buf, sizeof buf, "<main task>");
 986   return buf;
 987 }
 988
 989 static const char *
 990 core_thread_name (struct target_ops *self, struct thread_info *thr)
 991 {
 992   if (core_gdbarch
 993       && gdbarch_core_thread_name_p (core_gdbarch))
 994     return gdbarch_core_thread_name (core_gdbarch, thr);
 995   return NULL;
 996 }
 997
 998 static int
 999 core_has_memory (struct target_ops *ops)
1000 {
1001   return (core_bfd != NULL);
1002 }
1003
1004 static int
1005 core_has_stack (struct target_ops *ops)
1006 {
1007   return (core_bfd != NULL);
1008 }
1009
1010 static int
1011 core_has_registers (struct target_ops *ops)
1012 {
1013   return (core_bfd != NULL);
1014 }
1015
1016 /* Implement the to_info_proc method.  */
1017
1018 static void
1019 core_info_proc (struct target_ops *ops, const char *args,
1020                 enum info_proc_what request)
1021 {
1022   struct gdbarch *gdbarch = get_current_arch ();
1023
1024   /* Since this is the core file target, call the 'core_info_proc'
1025      method on gdbarch, not 'info_proc'.  */
1026   if (gdbarch_core_info_proc_p (gdbarch))
1027     gdbarch_core_info_proc (gdbarch, args, request);
1028 }
1029
1030 /* Fill in core_ops with its defined operations and properties.  */
1031
1032 static void
1033 init_core_ops (void)
1034 {
1035   core_ops.to_shortname = "core";
1036   core_ops.to_longname = "Local core dump file";
1037   core_ops.to_doc =
1038     "Use a core file as a target.  Specify the filename of the core file.";
1039   core_ops.to_open = core_open;
1040   core_ops.to_close = core_close;
1041   core_ops.to_detach = core_detach;
1042   core_ops.to_fetch_registers = get_core_registers;
1043   core_ops.to_xfer_partial = core_xfer_partial;
1044   core_ops.to_files_info = core_files_info;
1045   core_ops.to_insert_breakpoint = ignore;
1046   core_ops.to_remove_breakpoint = ignore;
1047   core_ops.to_thread_alive = core_thread_alive;
1048   core_ops.to_read_description = core_read_description;
1049   core_ops.to_pid_to_str = core_pid_to_str;
1050   core_ops.to_thread_name = core_thread_name;
1051   core_ops.to_stratum = process_stratum;
1052   core_ops.to_has_memory = core_has_memory;
1053   core_ops.to_has_stack = core_has_stack;
1054   core_ops.to_has_registers = core_has_registers;
1055   core_ops.to_info_proc = core_info_proc;
1056   core_ops.to_magic = OPS_MAGIC;
1057
1058   if (core_target)
1059     internal_error (__FILE__, __LINE__,
1060                     _("init_core_ops: core target already exists (\"%s\")."),
1061                     core_target->to_longname);
1062   core_target = &core_ops;
1063 }
1064
1065 void
1066 _initialize_corelow (void)
1067 {
1068   init_core_ops ();
1069
1070   add_target_with_completer (&core_ops, filename_completer);
1071 }