gdb/corelow.c

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