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