Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / corelow.c
1 /* Core dump and executable file functions below target vector, for GDB.
2
3    Copyright (C) 1986-2013 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 "gdb_string.h"
23 #include <errno.h>
24 #include <signal.h>
25 #include <fcntl.h>
26 #ifdef HAVE_SYS_FILE_H
27 #include <sys/file.h>           /* needed for F_OK and friends */
28 #endif
29 #include "frame.h"              /* required by inferior.h */
30 #include "inferior.h"
31 #include "symtab.h"
32 #include "command.h"
33 #include "bfd.h"
34 #include "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 "gdb_assert.h"
43 #include "exceptions.h"
44 #include "solib.h"
45 #include "filenames.h"
46 #include "progspace.h"
47 #include "objfiles.h"
48 #include "gdb_bfd.h"
49
50 #ifndef O_LARGEFILE
51 #define O_LARGEFILE 0
52 #endif
53
54 /* List of all available core_fns.  On gdb startup, each core file
55    register reader calls deprecated_add_core_fns() to register
56    information on each core format it is prepared to read.  */
57
58 static struct core_fns *core_file_fns = NULL;
59
60 /* The core_fns for a core file handler that is prepared to read the
61    core file currently open on core_bfd.  */
62
63 static struct core_fns *core_vec = NULL;
64
65 /* FIXME: kettenis/20031023: Eventually this variable should
66    disappear.  */
67
68 struct gdbarch *core_gdbarch = NULL;
69
70 /* Per-core data.  Currently, only the section table.  Note that these
71    target sections are *not* mapped in the current address spaces' set
72    of target sections --- those should come only from pure executable
73    or shared library bfds.  The core bfd sections are an
74    implementation detail of the core target, just like ptrace is for
75    unix child targets.  */
76 static struct target_section_table *core_data;
77
78 static void core_files_info (struct target_ops *);
79
80 static struct core_fns *sniff_core_bfd (bfd *);
81
82 static int gdb_check_format (bfd *);
83
84 static void core_open (char *, int);
85
86 static void core_detach (struct target_ops *ops, char *, int);
87
88 static void core_close (int);
89
90 static void core_close_cleanup (void *ignore);
91
92 static void add_to_thread_list (bfd *, asection *, void *);
93
94 static void init_core_ops (void);
95
96 void _initialize_corelow (void);
97
98 static struct target_ops core_ops;
99
100 /* An arbitrary identifier for the core inferior.  */
101 #define CORELOW_PID 1
102
103 /* Link a new core_fns into the global core_file_fns list.  Called on
104    gdb startup by the _initialize routine in each core file register
105    reader, to register information about each format the reader is
106    prepared to handle.  */
107
108 void
109 deprecated_add_core_fns (struct core_fns *cf)
110 {
111   cf->next = core_file_fns;
112   core_file_fns = cf;
113 }
114
115 /* The default function that core file handlers can use to examine a
116    core file BFD and decide whether or not to accept the job of
117    reading the core file.  */
118
119 int
120 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
121 {
122   int result;
123
124   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
125   return (result);
126 }
127
128 /* Walk through the list of core functions to find a set that can
129    handle the core file open on ABFD.  Returns pointer to set that is
130    selected.  */
131
132 static struct core_fns *
133 sniff_core_bfd (bfd *abfd)
134 {
135   struct core_fns *cf;
136   struct core_fns *yummy = NULL;
137   int matches = 0;;
138
139   /* Don't sniff if we have support for register sets in
140      CORE_GDBARCH.  */
141   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
142     return NULL;
143
144   for (cf = core_file_fns; cf != NULL; cf = cf->next)
145     {
146       if (cf->core_sniffer (cf, abfd))
147         {
148           yummy = cf;
149           matches++;
150         }
151     }
152   if (matches > 1)
153     {
154       warning (_("\"%s\": ambiguous core format, %d handlers match"),
155                bfd_get_filename (abfd), matches);
156     }
157   else if (matches == 0)
158     error (_("\"%s\": no core file handler recognizes format"),
159            bfd_get_filename (abfd));
160
161   return (yummy);
162 }
163
164 /* The default is to reject every core file format we see.  Either
165    BFD has to recognize it, or we have to provide a function in the
166    core file handler that recognizes it.  */
167
168 int
169 default_check_format (bfd *abfd)
170 {
171   return (0);
172 }
173
174 /* Attempt to recognize core file formats that BFD rejects.  */
175
176 static int
177 gdb_check_format (bfd *abfd)
178 {
179   struct core_fns *cf;
180
181   for (cf = core_file_fns; cf != NULL; cf = cf->next)
182     {
183       if (cf->check_format (abfd))
184         {
185           return (1);
186         }
187     }
188   return (0);
189 }
190
191 /* Discard all vestiges of any previous core file and mark data and
192    stack spaces as empty.  */
193
194 static void
195 core_close (int quitting)
196 {
197   if (core_bfd)
198     {
199       int pid = ptid_get_pid (inferior_ptid);
200       inferior_ptid = null_ptid;    /* Avoid confusion from thread
201                                        stuff.  */
202       if (pid != 0)
203         exit_inferior_silent (pid);
204
205       /* Clear out solib state while the bfd is still open.  See
206          comments in clear_solib in solib.c.  */
207       clear_solib ();
208
209       if (core_data)
210         {
211           xfree (core_data->sections);
212           xfree (core_data);
213           core_data = NULL;
214         }
215
216       gdb_bfd_unref (core_bfd);
217       core_bfd = NULL;
218     }
219   core_vec = NULL;
220   core_gdbarch = NULL;
221 }
222
223 static void
224 core_close_cleanup (void *ignore)
225 {
226   core_close (0/*ignored*/);
227 }
228
229 /* Look for sections whose names start with `.reg/' so that we can
230    extract the list of threads in a core file.  */
231
232 static void
233 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
234 {
235   ptid_t ptid;
236   int core_tid;
237   int pid, lwpid;
238   asection *reg_sect = (asection *) reg_sect_arg;
239   int fake_pid_p = 0;
240   struct inferior *inf;
241
242   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
243     return;
244
245   core_tid = atoi (bfd_section_name (abfd, asect) + 5);
246
247   pid = bfd_core_file_pid (core_bfd);
248   if (pid == 0)
249     {
250       fake_pid_p = 1;
251       pid = CORELOW_PID;
252     }
253
254   lwpid = core_tid;
255
256   inf = current_inferior ();
257   if (inf->pid == 0)
258     {
259       inferior_appeared (inf, pid);
260       inf->fake_pid_p = fake_pid_p;
261     }
262
263   ptid = ptid_build (pid, lwpid, 0);
264
265   add_thread (ptid);
266
267 /* Warning, Will Robinson, looking at BFD private data! */
268
269   if (reg_sect != NULL
270       && asect->filepos == reg_sect->filepos)   /* Did we find .reg?  */
271     inferior_ptid = ptid;                       /* Yes, make it current.  */
272 }
273
274 /* This routine opens and sets up the core file bfd.  */
275
276 static void
277 core_open (char *filename, int from_tty)
278 {
279   const char *p;
280   int siggy;
281   struct cleanup *old_chain;
282   char *temp;
283   bfd *temp_bfd;
284   int scratch_chan;
285   int flags;
286   volatile struct gdb_exception except;
287
288   target_preopen (from_tty);
289   if (!filename)
290     {
291       if (core_bfd)
292         error (_("No core file specified.  (Use `detach' "
293                  "to stop debugging a core file.)"));
294       else
295         error (_("No core file specified."));
296     }
297
298   filename = tilde_expand (filename);
299   if (!IS_ABSOLUTE_PATH (filename))
300     {
301       temp = concat (current_directory, "/",
302                      filename, (char *) NULL);
303       xfree (filename);
304       filename = temp;
305     }
306
307   old_chain = make_cleanup (xfree, filename);
308
309   flags = O_BINARY | O_LARGEFILE;
310   if (write_files)
311     flags |= O_RDWR;
312   else
313     flags |= O_RDONLY;
314   scratch_chan = open (filename, flags, 0);
315   if (scratch_chan < 0)
316     perror_with_name (filename);
317
318   temp_bfd = gdb_bfd_fopen (filename, gnutarget, 
319                             write_files ? FOPEN_RUB : FOPEN_RB,
320                             scratch_chan);
321   if (temp_bfd == NULL)
322     perror_with_name (filename);
323
324   if (!bfd_check_format (temp_bfd, bfd_core)
325       && !gdb_check_format (temp_bfd))
326     {
327       /* Do it after the err msg */
328       /* FIXME: should be checking for errors from bfd_close (for one
329          thing, on error it does not free all the storage associated
330          with the bfd).  */
331       make_cleanup_bfd_unref (temp_bfd);
332       error (_("\"%s\" is not a core dump: %s"),
333              filename, bfd_errmsg (bfd_get_error ()));
334     }
335
336   /* Looks semi-reasonable.  Toss the old core file and work on the
337      new.  */
338
339   do_cleanups (old_chain);
340   unpush_target (&core_ops);
341   core_bfd = temp_bfd;
342   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
343
344   core_gdbarch = gdbarch_from_bfd (core_bfd);
345
346   /* Find a suitable core file handler to munch on core_bfd */
347   core_vec = sniff_core_bfd (core_bfd);
348
349   validate_files ();
350
351   core_data = XZALLOC (struct target_section_table);
352
353   /* Find the data section */
354   if (build_section_table (core_bfd,
355                            &core_data->sections,
356                            &core_data->sections_end))
357     error (_("\"%s\": Can't find sections: %s"),
358            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
359
360   /* If we have no exec file, try to set the architecture from the
361      core file.  We don't do this unconditionally since an exec file
362      typically contains more information that helps us determine the
363      architecture than a core file.  */
364   if (!exec_bfd)
365     set_gdbarch_from_file (core_bfd);
366
367   push_target (&core_ops);
368   discard_cleanups (old_chain);
369
370   /* Do this before acknowledging the inferior, so if
371      post_create_inferior throws (can happen easilly if you're loading
372      a core file with the wrong exec), we aren't left with threads
373      from the previous inferior.  */
374   init_thread_list ();
375
376   inferior_ptid = null_ptid;
377
378   /* Need to flush the register cache (and the frame cache) from a
379      previous debug session.  If inferior_ptid ends up the same as the
380      last debug session --- e.g., b foo; run; gcore core1; step; gcore
381      core2; core core1; core core2 --- then there's potential for
382      get_current_regcache to return the cached regcache of the
383      previous session, and the frame cache being stale.  */
384   registers_changed ();
385
386   /* Build up thread list from BFD sections, and possibly set the
387      current thread to the .reg/NN section matching the .reg
388      section.  */
389   bfd_map_over_sections (core_bfd, add_to_thread_list,
390                          bfd_get_section_by_name (core_bfd, ".reg"));
391
392   if (ptid_equal (inferior_ptid, null_ptid))
393     {
394       /* Either we found no .reg/NN section, and hence we have a
395          non-threaded core (single-threaded, from gdb's perspective),
396          or for some reason add_to_thread_list couldn't determine
397          which was the "main" thread.  The latter case shouldn't
398          usually happen, but we're dealing with input here, which can
399          always be broken in different ways.  */
400       struct thread_info *thread = first_thread_of_process (-1);
401
402       if (thread == NULL)
403         {
404           inferior_appeared (current_inferior (), CORELOW_PID);
405           inferior_ptid = pid_to_ptid (CORELOW_PID);
406           add_thread_silent (inferior_ptid);
407         }
408       else
409         switch_to_thread (thread->ptid);
410     }
411
412   post_create_inferior (&core_ops, from_tty);
413
414   /* Now go through the target stack looking for threads since there
415      may be a thread_stratum target loaded on top of target core by
416      now.  The layer above should claim threads found in the BFD
417      sections.  */
418   TRY_CATCH (except, RETURN_MASK_ERROR)
419     {
420       target_find_new_threads ();
421     }
422
423   if (except.reason < 0)
424     exception_print (gdb_stderr, except);
425
426   p = bfd_core_file_failing_command (core_bfd);
427   if (p)
428     printf_filtered (_("Core was generated by `%s'.\n"), p);
429
430   siggy = bfd_core_file_failing_signal (core_bfd);
431   if (siggy > 0)
432     {
433       /* If we don't have a CORE_GDBARCH to work with, assume a native
434          core (map gdb_signal from host signals).  If we do have
435          CORE_GDBARCH to work with, but no gdb_signal_from_target
436          implementation for that gdbarch, as a fallback measure,
437          assume the host signal mapping.  It'll be correct for native
438          cores, but most likely incorrect for cross-cores.  */
439       enum gdb_signal sig = (core_gdbarch != NULL
440                              && gdbarch_gdb_signal_from_target_p (core_gdbarch)
441                              ? gdbarch_gdb_signal_from_target (core_gdbarch,
442                                                                siggy)
443                              : gdb_signal_from_host (siggy));
444
445       printf_filtered (_("Program terminated with signal %d, %s.\n"),
446                        siggy, gdb_signal_to_string (sig));
447     }
448
449   /* Fetch all registers from core file.  */
450   target_fetch_registers (get_current_regcache (), -1);
451
452   /* Now, set up the frame cache, and print the top of stack.  */
453   reinit_frame_cache ();
454   print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
455 }
456
457 static void
458 core_detach (struct target_ops *ops, char *args, int from_tty)
459 {
460   if (args)
461     error (_("Too many arguments"));
462   unpush_target (ops);
463   reinit_frame_cache ();
464   if (from_tty)
465     printf_filtered (_("No core file now.\n"));
466 }
467
468 #ifdef DEPRECATED_IBM6000_TARGET
469
470 /* Resize the core memory's section table, by NUM_ADDED.  Returns a
471    pointer into the first new slot.  This will not be necessary when
472    the rs6000 target is converted to use the standard solib
473    framework.  */
474
475 struct target_section *
476 deprecated_core_resize_section_table (int num_added)
477 {
478   int old_count;
479
480   old_count = resize_section_table (core_data, num_added);
481   return core_data->sections + old_count;
482 }
483
484 #endif
485
486 /* Try to retrieve registers from a section in core_bfd, and supply
487    them to core_vec->core_read_registers, as the register set numbered
488    WHICH.
489
490    If inferior_ptid's lwp member is zero, do the single-threaded
491    thing: look for a section named NAME.  If inferior_ptid's lwp
492    member is non-zero, do the multi-threaded thing: look for a section
493    named "NAME/LWP", where LWP is the shortest ASCII decimal
494    representation of inferior_ptid's lwp member.
495
496    HUMAN_NAME is a human-readable name for the kind of registers the
497    NAME section contains, for use in error messages.
498
499    If REQUIRED is non-zero, print an error if the core file doesn't
500    have a section by the appropriate name.  Otherwise, just do
501    nothing.  */
502
503 static void
504 get_core_register_section (struct regcache *regcache,
505                            const char *name,
506                            int which,
507                            const char *human_name,
508                            int required)
509 {
510   static char *section_name = NULL;
511   struct bfd_section *section;
512   bfd_size_type size;
513   char *contents;
514
515   xfree (section_name);
516
517   if (ptid_get_lwp (inferior_ptid))
518     section_name = xstrprintf ("%s/%ld", name,
519                                ptid_get_lwp (inferior_ptid));
520   else
521     section_name = xstrdup (name);
522
523   section = bfd_get_section_by_name (core_bfd, section_name);
524   if (! section)
525     {
526       if (required)
527         warning (_("Couldn't find %s registers in core file."),
528                  human_name);
529       return;
530     }
531
532   size = bfd_section_size (core_bfd, section);
533   contents = alloca (size);
534   if (! bfd_get_section_contents (core_bfd, section, contents,
535                                   (file_ptr) 0, size))
536     {
537       warning (_("Couldn't read %s registers from `%s' section in core file."),
538                human_name, name);
539       return;
540     }
541
542   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
543     {
544       const struct regset *regset;
545
546       regset = gdbarch_regset_from_core_section (core_gdbarch,
547                                                  name, size);
548       if (regset == NULL)
549         {
550           if (required)
551             warning (_("Couldn't recognize %s registers in core file."),
552                      human_name);
553           return;
554         }
555
556       regset->supply_regset (regset, regcache, -1, contents, size);
557       return;
558     }
559
560   gdb_assert (core_vec);
561   core_vec->core_read_registers (regcache, contents, size, which,
562                                  ((CORE_ADDR)
563                                   bfd_section_vma (core_bfd, section)));
564 }
565
566
567 /* Get the registers out of a core file.  This is the machine-
568    independent part.  Fetch_core_registers is the machine-dependent
569    part, typically implemented in the xm-file for each
570    architecture.  */
571
572 /* We just get all the registers, so we don't use regno.  */
573
574 static void
575 get_core_registers (struct target_ops *ops,
576                     struct regcache *regcache, int regno)
577 {
578   struct core_regset_section *sect_list;
579   int i;
580
581   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
582       && (core_vec == NULL || core_vec->core_read_registers == NULL))
583     {
584       fprintf_filtered (gdb_stderr,
585                      "Can't fetch registers from this type of core file\n");
586       return;
587     }
588
589   sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache));
590   if (sect_list)
591     while (sect_list->sect_name != NULL)
592       {
593         if (strcmp (sect_list->sect_name, ".reg") == 0)
594           get_core_register_section (regcache, sect_list->sect_name,
595                                      0, sect_list->human_name, 1);
596         else if (strcmp (sect_list->sect_name, ".reg2") == 0)
597           get_core_register_section (regcache, sect_list->sect_name,
598                                      2, sect_list->human_name, 0);
599         else
600           get_core_register_section (regcache, sect_list->sect_name,
601                                      3, sect_list->human_name, 0);
602
603         sect_list++;
604       }
605
606   else
607     {
608       get_core_register_section (regcache,
609                                  ".reg", 0, "general-purpose", 1);
610       get_core_register_section (regcache,
611                                  ".reg2", 2, "floating-point", 0);
612     }
613
614   /* Mark all registers not found in the core as unavailable.  */
615   for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
616     if (regcache_register_status (regcache, i) == REG_UNKNOWN)
617       regcache_raw_supply (regcache, i, NULL);
618 }
619
620 static void
621 core_files_info (struct target_ops *t)
622 {
623   print_section_info (core_data, core_bfd);
624 }
625 \f
626 struct spuid_list
627 {
628   gdb_byte *buf;
629   ULONGEST offset;
630   LONGEST len;
631   ULONGEST pos;
632   ULONGEST written;
633 };
634
635 static void
636 add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
637 {
638   struct spuid_list *list = list_p;
639   enum bfd_endian byte_order
640     = bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
641   int fd, pos = 0;
642
643   sscanf (bfd_section_name (abfd, asect), "SPU/%d/regs%n", &fd, &pos);
644   if (pos == 0)
645     return;
646
647   if (list->pos >= list->offset && list->pos + 4 <= list->offset + list->len)
648     {
649       store_unsigned_integer (list->buf + list->pos - list->offset,
650                               4, byte_order, fd);
651       list->written += 4;
652     }
653   list->pos += 4;
654 }
655
656 /* Read siginfo data from the core, if possible.  Returns -1 on
657    failure.  Otherwise, returns the number of bytes read.  ABFD is the
658    core file's BFD; READBUF, OFFSET, and LEN are all as specified by
659    the to_xfer_partial interface.  */
660
661 static LONGEST
662 get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, LONGEST len)
663 {
664   asection *section;
665   char *section_name;
666   const char *name = ".note.linuxcore.siginfo";
667
668   if (ptid_get_lwp (inferior_ptid))
669     section_name = xstrprintf ("%s/%ld", name,
670                                ptid_get_lwp (inferior_ptid));
671   else
672     section_name = xstrdup (name);
673
674   section = bfd_get_section_by_name (abfd, section_name);
675   xfree (section_name);
676   if (section == NULL)
677     return -1;
678
679   if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
680     return -1;
681
682   return len;
683 }
684
685 static LONGEST
686 core_xfer_partial (struct target_ops *ops, enum target_object object,
687                    const char *annex, gdb_byte *readbuf,
688                    const gdb_byte *writebuf, ULONGEST offset,
689                    LONGEST len)
690 {
691   switch (object)
692     {
693     case TARGET_OBJECT_MEMORY:
694       return section_table_xfer_memory_partial (readbuf, writebuf,
695                                                 offset, len,
696                                                 core_data->sections,
697                                                 core_data->sections_end,
698                                                 NULL);
699
700     case TARGET_OBJECT_AUXV:
701       if (readbuf)
702         {
703           /* When the aux vector is stored in core file, BFD
704              represents this with a fake section called ".auxv".  */
705
706           struct bfd_section *section;
707           bfd_size_type size;
708
709           section = bfd_get_section_by_name (core_bfd, ".auxv");
710           if (section == NULL)
711             return -1;
712
713           size = bfd_section_size (core_bfd, section);
714           if (offset >= size)
715             return 0;
716           size -= offset;
717           if (size > len)
718             size = len;
719           if (size > 0
720               && !bfd_get_section_contents (core_bfd, section, readbuf,
721                                             (file_ptr) offset, size))
722             {
723               warning (_("Couldn't read NT_AUXV note in core file."));
724               return -1;
725             }
726
727           return size;
728         }
729       return -1;
730
731     case TARGET_OBJECT_WCOOKIE:
732       if (readbuf)
733         {
734           /* When the StackGhost cookie is stored in core file, BFD
735              represents this with a fake section called
736              ".wcookie".  */
737
738           struct bfd_section *section;
739           bfd_size_type size;
740
741           section = bfd_get_section_by_name (core_bfd, ".wcookie");
742           if (section == NULL)
743             return -1;
744
745           size = bfd_section_size (core_bfd, section);
746           if (offset >= size)
747             return 0;
748           size -= offset;
749           if (size > len)
750             size = len;
751           if (size > 0
752               && !bfd_get_section_contents (core_bfd, section, readbuf,
753                                             (file_ptr) offset, size))
754             {
755               warning (_("Couldn't read StackGhost cookie in core file."));
756               return -1;
757             }
758
759           return size;
760         }
761       return -1;
762
763     case TARGET_OBJECT_LIBRARIES:
764       if (core_gdbarch
765           && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
766         {
767           if (writebuf)
768             return -1;
769           return
770             gdbarch_core_xfer_shared_libraries (core_gdbarch,
771                                                 readbuf, offset, len);
772         }
773       /* FALL THROUGH */
774
775     case TARGET_OBJECT_SPU:
776       if (readbuf && annex)
777         {
778           /* When the SPU contexts are stored in a core file, BFD
779              represents this with a fake section called
780              "SPU/<annex>".  */
781
782           struct bfd_section *section;
783           bfd_size_type size;
784           char sectionstr[100];
785
786           xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
787
788           section = bfd_get_section_by_name (core_bfd, sectionstr);
789           if (section == NULL)
790             return -1;
791
792           size = bfd_section_size (core_bfd, section);
793           if (offset >= size)
794             return 0;
795           size -= offset;
796           if (size > len)
797             size = len;
798           if (size > 0
799               && !bfd_get_section_contents (core_bfd, section, readbuf,
800                                             (file_ptr) offset, size))
801             {
802               warning (_("Couldn't read SPU section in core file."));
803               return -1;
804             }
805
806           return size;
807         }
808       else if (readbuf)
809         {
810           /* NULL annex requests list of all present spuids.  */
811           struct spuid_list list;
812
813           list.buf = readbuf;
814           list.offset = offset;
815           list.len = len;
816           list.pos = 0;
817           list.written = 0;
818           bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
819           return list.written;
820         }
821       return -1;
822
823     case TARGET_OBJECT_SIGNAL_INFO:
824       if (readbuf)
825         return get_core_siginfo (core_bfd, readbuf, offset, len);
826       return -1;
827
828     default:
829       if (ops->beneath != NULL)
830         return ops->beneath->to_xfer_partial (ops->beneath, object,
831                                               annex, readbuf,
832                                               writebuf, offset, len);
833       return -1;
834     }
835 }
836
837 \f
838 /* If mourn is being called in all the right places, this could be say
839    `gdb internal error' (since generic_mourn calls
840    breakpoint_init_inferior).  */
841
842 static int
843 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
844 {
845   return 0;
846 }
847
848
849 /* Okay, let's be honest: threads gleaned from a core file aren't
850    exactly lively, are they?  On the other hand, if we don't claim
851    that each & every one is alive, then we don't get any of them
852    to appear in an "info thread" command, which is quite a useful
853    behaviour.
854  */
855 static int
856 core_thread_alive (struct target_ops *ops, ptid_t ptid)
857 {
858   return 1;
859 }
860
861 /* Ask the current architecture what it knows about this core file.
862    That will be used, in turn, to pick a better architecture.  This
863    wrapper could be avoided if targets got a chance to specialize
864    core_ops.  */
865
866 static const struct target_desc *
867 core_read_description (struct target_ops *target)
868 {
869   if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
870     return gdbarch_core_read_description (core_gdbarch, 
871                                           target, core_bfd);
872
873   return NULL;
874 }
875
876 static char *
877 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
878 {
879   static char buf[64];
880   struct inferior *inf;
881   int pid;
882
883   /* The preferred way is to have a gdbarch/OS specific
884      implementation.  */
885   if (core_gdbarch
886       && gdbarch_core_pid_to_str_p (core_gdbarch))
887     return gdbarch_core_pid_to_str (core_gdbarch, ptid);
888
889   /* Otherwise, if we don't have one, we'll just fallback to
890      "process", with normal_pid_to_str.  */
891
892   /* Try the LWPID field first.  */
893   pid = ptid_get_lwp (ptid);
894   if (pid != 0)
895     return normal_pid_to_str (pid_to_ptid (pid));
896
897   /* Otherwise, this isn't a "threaded" core -- use the PID field, but
898      only if it isn't a fake PID.  */
899   inf = find_inferior_pid (ptid_get_pid (ptid));
900   if (inf != NULL && !inf->fake_pid_p)
901     return normal_pid_to_str (ptid);
902
903   /* No luck.  We simply don't have a valid PID to print.  */
904   xsnprintf (buf, sizeof buf, "<main task>");
905   return buf;
906 }
907
908 static int
909 core_has_memory (struct target_ops *ops)
910 {
911   return (core_bfd != NULL);
912 }
913
914 static int
915 core_has_stack (struct target_ops *ops)
916 {
917   return (core_bfd != NULL);
918 }
919
920 static int
921 core_has_registers (struct target_ops *ops)
922 {
923   return (core_bfd != NULL);
924 }
925
926 /* Implement the to_info_proc method.  */
927
928 static void
929 core_info_proc (struct target_ops *ops, char *args, enum info_proc_what request)
930 {
931   struct gdbarch *gdbarch = get_current_arch ();
932
933   /* Since this is the core file target, call the 'core_info_proc'
934      method on gdbarch, not 'info_proc'.  */
935   if (gdbarch_core_info_proc_p (gdbarch))
936     gdbarch_core_info_proc (gdbarch, args, request);
937 }
938
939 /* Fill in core_ops with its defined operations and properties.  */
940
941 static void
942 init_core_ops (void)
943 {
944   core_ops.to_shortname = "core";
945   core_ops.to_longname = "Local core dump file";
946   core_ops.to_doc =
947     "Use a core file as a target.  Specify the filename of the core file.";
948   core_ops.to_open = core_open;
949   core_ops.to_close = core_close;
950   core_ops.to_attach = find_default_attach;
951   core_ops.to_detach = core_detach;
952   core_ops.to_fetch_registers = get_core_registers;
953   core_ops.to_xfer_partial = core_xfer_partial;
954   core_ops.to_files_info = core_files_info;
955   core_ops.to_insert_breakpoint = ignore;
956   core_ops.to_remove_breakpoint = ignore;
957   core_ops.to_create_inferior = find_default_create_inferior;
958   core_ops.to_thread_alive = core_thread_alive;
959   core_ops.to_read_description = core_read_description;
960   core_ops.to_pid_to_str = core_pid_to_str;
961   core_ops.to_stratum = process_stratum;
962   core_ops.to_has_memory = core_has_memory;
963   core_ops.to_has_stack = core_has_stack;
964   core_ops.to_has_registers = core_has_registers;
965   core_ops.to_info_proc = core_info_proc;
966   core_ops.to_magic = OPS_MAGIC;
967
968   if (core_target)
969     internal_error (__FILE__, __LINE__, 
970                     _("init_core_ops: core target already exists (\"%s\")."),
971                     core_target->to_longname);
972   core_target = &core_ops;
973 }
974
975 void
976 _initialize_corelow (void)
977 {
978   init_core_ops ();
979
980   add_target (&core_ops);
981 }