gdb/corelow.c

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