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