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