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 "common/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   int fake_pid_p = 0;
 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 = 1;
 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_RETURN_MASK_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_RETURN_MASK_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   reinit_frame_cache ();
 539   maybe_say_no_core_file_now (from_tty);
 540 }
 541
 542 /* Try to retrieve registers from a section in core_bfd, and supply
 543    them to m_core_vec->core_read_registers, as the register set
 544    numbered WHICH.
 545
 546    If ptid's lwp member is zero, do the single-threaded
 547    thing: look for a section named NAME.  If ptid's lwp
 548    member is non-zero, do the multi-threaded thing: look for a section
 549    named "NAME/LWP", where LWP is the shortest ASCII decimal
 550    representation of ptid's lwp member.
 551
 552    HUMAN_NAME is a human-readable name for the kind of registers the
 553    NAME section contains, for use in error messages.
 554
 555    If REQUIRED is true, print an error if the core file doesn't have a
 556    section by the appropriate name.  Otherwise, just do nothing.  */
 557
 558 void
 559 core_target::get_core_register_section (struct regcache *regcache,
 560                                         const struct regset *regset,
 561                                         const char *name,
 562                                         int section_min_size,
 563                                         int which,
 564                                         const char *human_name,
 565                                         bool required)
 566 {
 567   struct bfd_section *section;
 568   bfd_size_type size;
 569   char *contents;
 570   bool variable_size_section = (regset != NULL
 571                                 && regset->flags & REGSET_VARIABLE_SIZE);
 572
 573   thread_section_name section_name (name, regcache->ptid ());
 574
 575   section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
 576   if (! section)
 577     {
 578       if (required)
 579         warning (_("Couldn't find %s registers in core file."),
 580                  human_name);
 581       return;
 582     }
 583
 584   size = bfd_section_size (core_bfd, section);
 585   if (size < section_min_size)
 586     {
 587       warning (_("Section `%s' in core file too small."),
 588                section_name.c_str ());
 589       return;
 590     }
 591   if (size != section_min_size && !variable_size_section)
 592     {
 593       warning (_("Unexpected size of section `%s' in core file."),
 594                section_name.c_str ());
 595     }
 596
 597   contents = (char *) alloca (size);
 598   if (! bfd_get_section_contents (core_bfd, section, contents,
 599                                   (file_ptr) 0, size))
 600     {
 601       warning (_("Couldn't read %s registers from `%s' section in core file."),
 602                human_name, section_name.c_str ());
 603       return;
 604     }
 605
 606   if (regset != NULL)
 607     {
 608       regset->supply_regset (regset, regcache, -1, contents, size);
 609       return;
 610     }
 611
 612   gdb_assert (m_core_vec != nullptr);
 613   m_core_vec->core_read_registers (regcache, contents, size, which,
 614                                    ((CORE_ADDR)
 615                                     bfd_section_vma (core_bfd, section)));
 616 }
 617
 618 /* Data passed to gdbarch_iterate_over_regset_sections's callback.  */
 619 struct get_core_registers_cb_data
 620 {
 621   core_target *target;
 622   struct regcache *regcache;
 623 };
 624
 625 /* Callback for get_core_registers that handles a single core file
 626    register note section. */
 627
 628 static void
 629 get_core_registers_cb (const char *sect_name, int supply_size, int collect_size,
 630                        const struct regset *regset,
 631                        const char *human_name, void *cb_data)
 632 {
 633   auto *data = (get_core_registers_cb_data *) cb_data;
 634   bool required = false;
 635   bool variable_size_section = (regset != NULL
 636                                 && regset->flags & REGSET_VARIABLE_SIZE);
 637
 638   if (!variable_size_section)
 639     gdb_assert (supply_size == collect_size);
 640
 641   if (strcmp (sect_name, ".reg") == 0)
 642     {
 643       required = true;
 644       if (human_name == NULL)
 645         human_name = "general-purpose";
 646     }
 647   else if (strcmp (sect_name, ".reg2") == 0)
 648     {
 649       if (human_name == NULL)
 650         human_name = "floating-point";
 651     }
 652
 653   /* The 'which' parameter is only used when no regset is provided.
 654      Thus we just set it to -1. */
 655   data->target->get_core_register_section (data->regcache, regset, sect_name,
 656                                            supply_size, -1, human_name,
 657                                            required);
 658 }
 659
 660 /* Get the registers out of a core file.  This is the machine-
 661    independent part.  Fetch_core_registers is the machine-dependent
 662    part, typically implemented in the xm-file for each
 663    architecture.  */
 664
 665 /* We just get all the registers, so we don't use regno.  */
 666
 667 void
 668 core_target::fetch_registers (struct regcache *regcache, int regno)
 669 {
 670   int i;
 671   struct gdbarch *gdbarch;
 672
 673   if (!(m_core_gdbarch != nullptr
 674         && gdbarch_iterate_over_regset_sections_p (m_core_gdbarch))
 675       && (m_core_vec == NULL || m_core_vec->core_read_registers == NULL))
 676     {
 677       fprintf_filtered (gdb_stderr,
 678                      "Can't fetch registers from this type of core file\n");
 679       return;
 680     }
 681
 682   gdbarch = regcache->arch ();
 683   if (gdbarch_iterate_over_regset_sections_p (gdbarch))
 684     {
 685       get_core_registers_cb_data data = { this, regcache };
 686       gdbarch_iterate_over_regset_sections (gdbarch,
 687                                             get_core_registers_cb,
 688                                             (void *) &data, NULL);
 689     }
 690   else
 691     {
 692       get_core_register_section (regcache, NULL,
 693                                  ".reg", 0, 0, "general-purpose", 1);
 694       get_core_register_section (regcache, NULL,
 695                                  ".reg2", 0, 2, "floating-point", 0);
 696     }
 697
 698   /* Mark all registers not found in the core as unavailable.  */
 699   for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
 700     if (regcache->get_register_status (i) == REG_UNKNOWN)
 701       regcache->raw_supply (i, NULL);
 702 }
 703
 704 void
 705 core_target::files_info ()
 706 {
 707   print_section_info (&m_core_section_table, core_bfd);
 708 }
 709 \f
 710 struct spuid_list
 711 {
 712   gdb_byte *buf;
 713   ULONGEST offset;
 714   LONGEST len;
 715   ULONGEST pos;
 716   ULONGEST written;
 717 };
 718
 719 static void
 720 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
 721 {
 722   struct spuid_list *list = (struct spuid_list *) list_p;
 723   enum bfd_endian byte_order
 724     = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
 725   int fd, pos = 0;
 726
 727   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
 728   if (pos == 0)
 729     return;
 730
 731   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
 732     {
 733       store_unsigned_integer (list->buf + list->pos - list->offset,
 734                               4, byte_order, fd);
 735       list->written += 4;
 736     }
 737   list->pos += 4;
 738 }
 739
 740 enum target_xfer_status
 741 core_target::xfer_partial (enum target_object object, const char *annex,
 742                            gdb_byte *readbuf, const gdb_byte *writebuf,
 743                            ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 744 {
 745   switch (object)
 746     {
 747     case TARGET_OBJECT_MEMORY:
 748       return (section_table_xfer_memory_partial
 749               (readbuf, writebuf,
 750                offset, len, xfered_len,
 751                m_core_section_table.sections,
 752                m_core_section_table.sections_end,
 753                NULL));
 754
 755     case TARGET_OBJECT_AUXV:
 756       if (readbuf)
 757         {
 758           /* When the aux vector is stored in core file, BFD
 759              represents this with a fake section called ".auxv".  */
 760
 761           struct bfd_section *section;
 762           bfd_size_type size;
 763
 764           section = bfd_get_section_by_name (core_bfd, ".auxv");
 765           if (section == NULL)
 766             return TARGET_XFER_E_IO;
 767
 768           size = bfd_section_size (core_bfd, section);
 769           if (offset >= size)
 770             return TARGET_XFER_EOF;
 771           size -= offset;
 772           if (size > len)
 773             size = len;
 774
 775           if (size == 0)
 776             return TARGET_XFER_EOF;
 777           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 778                                          (file_ptr) offset, size))
 779             {
 780               warning (_("Couldn't read NT_AUXV note in core file."));
 781               return TARGET_XFER_E_IO;
 782             }
 783
 784           *xfered_len = (ULONGEST) size;
 785           return TARGET_XFER_OK;
 786         }
 787       return TARGET_XFER_E_IO;
 788
 789     case TARGET_OBJECT_WCOOKIE:
 790       if (readbuf)
 791         {
 792           /* When the StackGhost cookie is stored in core file, BFD
 793              represents this with a fake section called
 794              ".wcookie".  */
 795
 796           struct bfd_section *section;
 797           bfd_size_type size;
 798
 799           section = bfd_get_section_by_name (core_bfd, ".wcookie");
 800           if (section == NULL)
 801             return TARGET_XFER_E_IO;
 802
 803           size = bfd_section_size (core_bfd, section);
 804           if (offset >= size)
 805             return TARGET_XFER_EOF;
 806           size -= offset;
 807           if (size > len)
 808             size = len;
 809
 810           if (size == 0)
 811             return TARGET_XFER_EOF;
 812           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 813                                          (file_ptr) offset, size))
 814             {
 815               warning (_("Couldn't read StackGhost cookie in core file."));
 816               return TARGET_XFER_E_IO;
 817             }
 818
 819           *xfered_len = (ULONGEST) size;
 820           return TARGET_XFER_OK;
 821
 822         }
 823       return TARGET_XFER_E_IO;
 824
 825     case TARGET_OBJECT_LIBRARIES:
 826       if (m_core_gdbarch != nullptr
 827           && gdbarch_core_xfer_shared_libraries_p (m_core_gdbarch))
 828         {
 829           if (writebuf)
 830             return TARGET_XFER_E_IO;
 831           else
 832             {
 833               *xfered_len = gdbarch_core_xfer_shared_libraries (m_core_gdbarch,
 834                                                                 readbuf,
 835                                                                 offset, len);
 836
 837               if (*xfered_len == 0)
 838                 return TARGET_XFER_EOF;
 839               else
 840                 return TARGET_XFER_OK;
 841             }
 842         }
 843       /* FALL THROUGH */
 844
 845     case TARGET_OBJECT_LIBRARIES_AIX:
 846       if (m_core_gdbarch != nullptr
 847           && gdbarch_core_xfer_shared_libraries_aix_p (m_core_gdbarch))
 848         {
 849           if (writebuf)
 850             return TARGET_XFER_E_IO;
 851           else
 852             {
 853               *xfered_len
 854                 = gdbarch_core_xfer_shared_libraries_aix (m_core_gdbarch,
 855                                                           readbuf, offset,
 856                                                           len);
 857
 858               if (*xfered_len == 0)
 859                 return TARGET_XFER_EOF;
 860               else
 861                 return TARGET_XFER_OK;
 862             }
 863         }
 864       /* FALL THROUGH */
 865
 866     case TARGET_OBJECT_SPU:
 867       if (readbuf && annex)
 868         {
 869           /* When the SPU contexts are stored in a core file, BFD
 870              represents this with a fake section called
 871              "SPU/<annex>".  */
 872
 873           struct bfd_section *section;
 874           bfd_size_type size;
 875           char sectionstr[100];
 876
 877           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
 878
 879           section = bfd_get_section_by_name (core_bfd, sectionstr);
 880           if (section == NULL)
 881             return TARGET_XFER_E_IO;
 882
 883           size = bfd_section_size (core_bfd, section);
 884           if (offset >= size)
 885             return TARGET_XFER_EOF;
 886           size -= offset;
 887           if (size > len)
 888             size = len;
 889
 890           if (size == 0)
 891             return TARGET_XFER_EOF;
 892           if (!bfd_get_section_contents (core_bfd, section, readbuf,
 893                                          (file_ptr) offset, size))
 894             {
 895               warning (_("Couldn't read SPU section in core file."));
 896               return TARGET_XFER_E_IO;
 897             }
 898
 899           *xfered_len = (ULONGEST) size;
 900           return TARGET_XFER_OK;
 901         }
 902       else if (readbuf)
 903         {
 904           /* NULL annex requests list of all present spuids.  */
 905           struct spuid_list list;
 906
 907           list.buf = readbuf;
 908           list.offset = offset;
 909           list.len = len;
 910           list.pos = 0;
 911           list.written = 0;
 912           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
 913
 914           if (list.written == 0)
 915             return TARGET_XFER_EOF;
 916           else
 917             {
 918               *xfered_len = (ULONGEST) list.written;
 919               return TARGET_XFER_OK;
 920             }
 921         }
 922       return TARGET_XFER_E_IO;
 923
 924     case TARGET_OBJECT_SIGNAL_INFO:
 925       if (readbuf)
 926         {
 927           if (m_core_gdbarch != nullptr
 928               && gdbarch_core_xfer_siginfo_p (m_core_gdbarch))
 929             {
 930               LONGEST l = gdbarch_core_xfer_siginfo  (m_core_gdbarch, readbuf,
 931                                                       offset, len);
 932
 933               if (l >= 0)
 934                 {
 935                   *xfered_len = l;
 936                   if (l == 0)
 937                     return TARGET_XFER_EOF;
 938                   else
 939                     return TARGET_XFER_OK;
 940                 }
 941             }
 942         }
 943       return TARGET_XFER_E_IO;
 944
 945     default:
 946       return this->beneath ()->xfer_partial (object, annex, readbuf,
 947                                              writebuf, offset, len,
 948                                              xfered_len);
 949     }
 950 }
 951
 952 \f
 953
 954 /* Okay, let's be honest: threads gleaned from a core file aren't
 955    exactly lively, are they?  On the other hand, if we don't claim
 956    that each & every one is alive, then we don't get any of them
 957    to appear in an "info thread" command, which is quite a useful
 958    behaviour.
 959  */
 960 bool
 961 core_target::thread_alive (ptid_t ptid)
 962 {
 963   return true;
 964 }
 965
 966 /* Ask the current architecture what it knows about this core file.
 967    That will be used, in turn, to pick a better architecture.  This
 968    wrapper could be avoided if targets got a chance to specialize
 969    core_target.  */
 970
 971 const struct target_desc *
 972 core_target::read_description ()
 973 {
 974   if (m_core_gdbarch && gdbarch_core_read_description_p (m_core_gdbarch))
 975     {
 976       const struct target_desc *result;
 977
 978       result = gdbarch_core_read_description (m_core_gdbarch, this, core_bfd);
 979       if (result != NULL)
 980         return result;
 981     }
 982
 983   return this->beneath ()->read_description ();
 984 }
 985
 986 std::string
 987 core_target::pid_to_str (ptid_t ptid)
 988 {
 989   struct inferior *inf;
 990   int pid;
 991
 992   /* The preferred way is to have a gdbarch/OS specific
 993      implementation.  */
 994   if (m_core_gdbarch != nullptr
 995       && gdbarch_core_pid_to_str_p (m_core_gdbarch))
 996     return gdbarch_core_pid_to_str (m_core_gdbarch, ptid);
 997
 998   /* Otherwise, if we don't have one, we'll just fallback to
 999      "process", with normal_pid_to_str.  */
1000
1001   /* Try the LWPID field first.  */
1002   pid = ptid.lwp ();
1003   if (pid != 0)
1004     return normal_pid_to_str (ptid_t (pid));
1005
1006   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
1007      only if it isn't a fake PID.  */
1008   inf = find_inferior_ptid (ptid);
1009   if (inf != NULL && !inf->fake_pid_p)
1010     return normal_pid_to_str (ptid);
1011
1012   /* No luck.  We simply don't have a valid PID to print.  */
1013   return "<main task>";
1014 }
1015
1016 const char *
1017 core_target::thread_name (struct thread_info *thr)
1018 {
1019   if (m_core_gdbarch != nullptr
1020       && gdbarch_core_thread_name_p (m_core_gdbarch))
1021     return gdbarch_core_thread_name (m_core_gdbarch, thr);
1022   return NULL;
1023 }
1024
1025 bool
1026 core_target::has_memory ()
1027 {
1028   return (core_bfd != NULL);
1029 }
1030
1031 bool
1032 core_target::has_stack ()
1033 {
1034   return (core_bfd != NULL);
1035 }
1036
1037 bool
1038 core_target::has_registers ()
1039 {
1040   return (core_bfd != NULL);
1041 }
1042
1043 /* Implement the to_info_proc method.  */
1044
1045 bool
1046 core_target::info_proc (const char *args, enum info_proc_what request)
1047 {
1048   struct gdbarch *gdbarch = get_current_arch ();
1049
1050   /* Since this is the core file target, call the 'core_info_proc'
1051      method on gdbarch, not 'info_proc'.  */
1052   if (gdbarch_core_info_proc_p (gdbarch))
1053     gdbarch_core_info_proc (gdbarch, args, request);
1054
1055   return true;
1056 }
1057
1058 void
1059 _initialize_corelow (void)
1060 {
1061   add_target (core_target_info, core_target_open, filename_completer);
1062 }