2007-05-31 Markus Deuling <deuling@de.ibm.com>
[platform/upstream/binutils.git] / gdb / corelow.c
1 /* Core dump and executable file functions below target vector, for GDB.
2
3    Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4    1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007
5    Free Software Foundation, Inc.
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
22    Boston, MA 02110-1301, USA.  */
23
24 #include "defs.h"
25 #include "arch-utils.h"
26 #include "gdb_string.h"
27 #include <errno.h>
28 #include <signal.h>
29 #include <fcntl.h>
30 #ifdef HAVE_SYS_FILE_H
31 #include <sys/file.h>           /* needed for F_OK and friends */
32 #endif
33 #include "frame.h"              /* required by inferior.h */
34 #include "inferior.h"
35 #include "symtab.h"
36 #include "command.h"
37 #include "bfd.h"
38 #include "target.h"
39 #include "gdbcore.h"
40 #include "gdbthread.h"
41 #include "regcache.h"
42 #include "regset.h"
43 #include "symfile.h"
44 #include "exec.h"
45 #include "readline/readline.h"
46 #include "gdb_assert.h"
47 #include "exceptions.h"
48 #include "solib.h"
49
50
51 #ifndef O_LARGEFILE
52 #define O_LARGEFILE 0
53 #endif
54
55 /* List of all available core_fns.  On gdb startup, each core file
56    register reader calls deprecated_add_core_fns() to register
57    information on each core format it is prepared to read.  */
58
59 static struct core_fns *core_file_fns = NULL;
60
61 /* The core_fns for a core file handler that is prepared to read the core
62    file currently open on core_bfd. */
63
64 static struct core_fns *core_vec = NULL;
65
66 /* FIXME: kettenis/20031023: Eventually this variable should
67    disappear.  */
68
69 struct gdbarch *core_gdbarch = NULL;
70
71 static void core_files_info (struct target_ops *);
72
73 static struct core_fns *sniff_core_bfd (bfd *);
74
75 static int gdb_check_format (bfd *);
76
77 static void core_open (char *, int);
78
79 static void core_detach (char *, int);
80
81 static void core_close (int);
82
83 static void core_close_cleanup (void *ignore);
84
85 static void get_core_registers (struct regcache *, int);
86
87 static void add_to_thread_list (bfd *, asection *, void *);
88
89 static int core_file_thread_alive (ptid_t tid);
90
91 static void init_core_ops (void);
92
93 void _initialize_corelow (void);
94
95 struct target_ops core_ops;
96
97 /* Link a new core_fns into the global core_file_fns list.  Called on gdb
98    startup by the _initialize routine in each core file register reader, to
99    register information about each format the the reader is prepared to
100    handle. */
101
102 void
103 deprecated_add_core_fns (struct core_fns *cf)
104 {
105   cf->next = core_file_fns;
106   core_file_fns = cf;
107 }
108
109 /* The default function that core file handlers can use to examine a
110    core file BFD and decide whether or not to accept the job of
111    reading the core file. */
112
113 int
114 default_core_sniffer (struct core_fns *our_fns, bfd *abfd)
115 {
116   int result;
117
118   result = (bfd_get_flavour (abfd) == our_fns -> core_flavour);
119   return (result);
120 }
121
122 /* Walk through the list of core functions to find a set that can
123    handle the core file open on ABFD.  Default to the first one in the
124    list if nothing matches.  Returns pointer to set that is
125    selected. */
126
127 static struct core_fns *
128 sniff_core_bfd (bfd *abfd)
129 {
130   struct core_fns *cf;
131   struct core_fns *yummy = NULL;
132   int matches = 0;;
133
134   /* Don't sniff if we have support for register sets in CORE_GDBARCH.  */
135   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
136     return NULL;
137
138   for (cf = core_file_fns; cf != NULL; cf = cf->next)
139     {
140       if (cf->core_sniffer (cf, abfd))
141         {
142           yummy = cf;
143           matches++;
144         }
145     }
146   if (matches > 1)
147     {
148       warning (_("\"%s\": ambiguous core format, %d handlers match"),
149                bfd_get_filename (abfd), matches);
150     }
151   else if (matches == 0)
152     {
153       warning (_("\"%s\": no core file handler recognizes format, using default"),
154                bfd_get_filename (abfd));
155     }
156   if (yummy == NULL)
157     {
158       yummy = core_file_fns;
159     }
160   return (yummy);
161 }
162
163 /* The default is to reject every core file format we see.  Either
164    BFD has to recognize it, or we have to provide a function in the
165    core file handler that recognizes it. */
166
167 int
168 default_check_format (bfd *abfd)
169 {
170   return (0);
171 }
172
173 /* Attempt to recognize core file formats that BFD rejects. */
174
175 static int
176 gdb_check_format (bfd *abfd)
177 {
178   struct core_fns *cf;
179
180   for (cf = core_file_fns; cf != NULL; cf = cf->next)
181     {
182       if (cf->check_format (abfd))
183         {
184           return (1);
185         }
186     }
187   return (0);
188 }
189
190 /* Discard all vestiges of any previous core file and mark data and stack
191    spaces as empty.  */
192
193 static void
194 core_close (int quitting)
195 {
196   char *name;
197
198   if (core_bfd)
199     {
200       inferior_ptid = null_ptid;        /* Avoid confusion from thread stuff */
201
202       /* Clear out solib state while the bfd is still open. See
203          comments in clear_solib in solib.c. */
204 #ifdef CLEAR_SOLIB
205       CLEAR_SOLIB ();
206 #else
207       clear_solib ();
208 #endif
209
210       name = bfd_get_filename (core_bfd);
211       if (!bfd_close (core_bfd))
212         warning (_("cannot close \"%s\": %s"),
213                  name, bfd_errmsg (bfd_get_error ()));
214       xfree (name);
215       core_bfd = NULL;
216       if (core_ops.to_sections)
217         {
218           xfree (core_ops.to_sections);
219           core_ops.to_sections = NULL;
220           core_ops.to_sections_end = NULL;
221         }
222     }
223   core_vec = NULL;
224   core_gdbarch = NULL;
225 }
226
227 static void
228 core_close_cleanup (void *ignore)
229 {
230   core_close (0/*ignored*/);
231 }
232
233 /* Look for sections whose names start with `.reg/' so that we can extract the
234    list of threads in a core file.  */
235
236 static void
237 add_to_thread_list (bfd *abfd, asection *asect, void *reg_sect_arg)
238 {
239   int thread_id;
240   asection *reg_sect = (asection *) reg_sect_arg;
241
242   if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
243     return;
244
245   thread_id = atoi (bfd_section_name (abfd, asect) + 5);
246
247   add_thread (pid_to_ptid (thread_id));
248
249 /* Warning, Will Robinson, looking at BFD private data! */
250
251   if (reg_sect != NULL
252       && asect->filepos == reg_sect->filepos)   /* Did we find .reg? */
253     inferior_ptid = pid_to_ptid (thread_id);    /* Yes, make it current */
254 }
255
256 /* This routine opens and sets up the core file bfd.  */
257
258 static void
259 core_open (char *filename, int from_tty)
260 {
261   const char *p;
262   int siggy;
263   struct cleanup *old_chain;
264   char *temp;
265   bfd *temp_bfd;
266   int ontop;
267   int scratch_chan;
268   int flags;
269
270   target_preopen (from_tty);
271   if (!filename)
272     {
273       if (core_bfd)
274         error (_("No core file specified.  (Use `detach' to stop debugging a core file.)"));
275       else
276         error (_("No core file specified."));
277     }
278
279   filename = tilde_expand (filename);
280   if (filename[0] != '/')
281     {
282       temp = concat (current_directory, "/", filename, (char *)NULL);
283       xfree (filename);
284       filename = temp;
285     }
286
287   old_chain = make_cleanup (xfree, filename);
288
289   flags = O_BINARY | O_LARGEFILE;
290   if (write_files)
291     flags |= O_RDWR;
292   else
293     flags |= O_RDONLY;
294   scratch_chan = open (filename, flags, 0);
295   if (scratch_chan < 0)
296     perror_with_name (filename);
297
298   temp_bfd = bfd_fopen (filename, gnutarget, 
299                         write_files ? FOPEN_RUB : FOPEN_RB,
300                         scratch_chan);
301   if (temp_bfd == NULL)
302     perror_with_name (filename);
303
304   if (!bfd_check_format (temp_bfd, bfd_core) &&
305       !gdb_check_format (temp_bfd))
306     {
307       /* Do it after the err msg */
308       /* FIXME: should be checking for errors from bfd_close (for one thing,
309          on error it does not free all the storage associated with the
310          bfd).  */
311       make_cleanup_bfd_close (temp_bfd);
312       error (_("\"%s\" is not a core dump: %s"),
313              filename, bfd_errmsg (bfd_get_error ()));
314     }
315
316   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
317
318   discard_cleanups (old_chain); /* Don't free filename any more */
319   unpush_target (&core_ops);
320   core_bfd = temp_bfd;
321   old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
322
323   /* FIXME: kettenis/20031023: This is very dangerous.  The
324      CORE_GDBARCH that results from this call may very well be
325      different from CURRENT_GDBARCH.  However, its methods may only
326      work if it is selected as the current architecture, because they
327      rely on swapped data (see gdbarch.c).  We should get rid of that
328      swapped data.  */
329   core_gdbarch = gdbarch_from_bfd (core_bfd);
330
331   /* Find a suitable core file handler to munch on core_bfd */
332   core_vec = sniff_core_bfd (core_bfd);
333
334   validate_files ();
335
336   /* Find the data section */
337   if (build_section_table (core_bfd, &core_ops.to_sections,
338                            &core_ops.to_sections_end))
339     error (_("\"%s\": Can't find sections: %s"),
340            bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
341
342   /* If we have no exec file, try to set the architecture from the
343      core file.  We don't do this unconditionally since an exec file
344      typically contains more information that helps us determine the
345      architecture than a core file.  */
346   if (!exec_bfd)
347     set_gdbarch_from_file (core_bfd);
348
349   ontop = !push_target (&core_ops);
350   discard_cleanups (old_chain);
351
352   /* This is done first, before anything has a chance to query the
353      inferior for information such as symbols.  */
354   post_create_inferior (&core_ops, from_tty);
355
356   p = bfd_core_file_failing_command (core_bfd);
357   if (p)
358     printf_filtered (_("Core was generated by `%s'.\n"), p);
359
360   siggy = bfd_core_file_failing_signal (core_bfd);
361   if (siggy > 0)
362     /* NOTE: target_signal_from_host() converts a target signal value
363        into gdb's internal signal value.  Unfortunately gdb's internal
364        value is called ``target_signal'' and this function got the
365        name ..._from_host(). */
366     printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
367                      target_signal_to_string (target_signal_from_host (siggy)));
368
369   /* Build up thread list from BFD sections. */
370
371   init_thread_list ();
372   bfd_map_over_sections (core_bfd, add_to_thread_list,
373                          bfd_get_section_by_name (core_bfd, ".reg"));
374
375   if (ontop)
376     {
377       /* Fetch all registers from core file.  */
378       target_fetch_registers (current_regcache, -1);
379
380       /* Now, set up the frame cache, and print the top of stack.  */
381       reinit_frame_cache ();
382       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
383     }
384   else
385     {
386       warning (
387                 "you won't be able to access this core file until you terminate\n\
388 your %s; do ``info files''", target_longname);
389     }
390 }
391
392 static void
393 core_detach (char *args, int from_tty)
394 {
395   if (args)
396     error (_("Too many arguments"));
397   unpush_target (&core_ops);
398   reinit_frame_cache ();
399   if (from_tty)
400     printf_filtered (_("No core file now.\n"));
401 }
402
403
404 /* Try to retrieve registers from a section in core_bfd, and supply
405    them to core_vec->core_read_registers, as the register set numbered
406    WHICH.
407
408    If inferior_ptid is zero, do the single-threaded thing: look for a
409    section named NAME.  If inferior_ptid is non-zero, do the
410    multi-threaded thing: look for a section named "NAME/PID", where
411    PID is the shortest ASCII decimal representation of inferior_ptid.
412
413    HUMAN_NAME is a human-readable name for the kind of registers the
414    NAME section contains, for use in error messages.
415
416    If REQUIRED is non-zero, print an error if the core file doesn't
417    have a section by the appropriate name.  Otherwise, just do nothing.  */
418
419 static void
420 get_core_register_section (struct regcache *regcache,
421                            char *name,
422                            int which,
423                            char *human_name,
424                            int required)
425 {
426   static char *section_name = NULL;
427   struct bfd_section *section;
428   bfd_size_type size;
429   char *contents;
430
431   xfree (section_name);
432   if (PIDGET (inferior_ptid))
433     section_name = xstrprintf ("%s/%d", name, PIDGET (inferior_ptid));
434   else
435     section_name = xstrdup (name);
436
437   section = bfd_get_section_by_name (core_bfd, section_name);
438   if (! section)
439     {
440       if (required)
441         warning (_("Couldn't find %s registers in core file."), human_name);
442       return;
443     }
444
445   size = bfd_section_size (core_bfd, section);
446   contents = alloca (size);
447   if (! bfd_get_section_contents (core_bfd, section, contents,
448                                   (file_ptr) 0, size))
449     {
450       warning (_("Couldn't read %s registers from `%s' section in core file."),
451                human_name, name);
452       return;
453     }
454
455   if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
456     {
457       const struct regset *regset;
458
459       regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
460       if (regset == NULL)
461         {
462           if (required)
463             warning (_("Couldn't recognize %s registers in core file."),
464                      human_name);
465           return;
466         }
467
468       regset->supply_regset (regset, regcache, -1, contents, size);
469       return;
470     }
471
472   gdb_assert (core_vec);
473   core_vec->core_read_registers (regcache, contents, size, which,
474                                  ((CORE_ADDR)
475                                   bfd_section_vma (core_bfd, section)));
476 }
477
478
479 /* Get the registers out of a core file.  This is the machine-
480    independent part.  Fetch_core_registers is the machine-dependent
481    part, typically implemented in the xm-file for each architecture.  */
482
483 /* We just get all the registers, so we don't use regno.  */
484
485 static void
486 get_core_registers (struct regcache *regcache, int regno)
487 {
488   int i;
489
490   if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
491       && (core_vec == NULL || core_vec->core_read_registers == NULL))
492     {
493       fprintf_filtered (gdb_stderr,
494                      "Can't fetch registers from this type of core file\n");
495       return;
496     }
497
498   get_core_register_section (regcache,
499                              ".reg", 0, "general-purpose", 1);
500   get_core_register_section (regcache,
501                              ".reg2", 2, "floating-point", 0);
502   get_core_register_section (regcache,
503                              ".reg-xfp", 3, "extended floating-point", 0);
504
505   /* Supply dummy value for all registers not found in the core.  */
506   for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
507     if (!regcache_valid_p (regcache, i))
508       regcache_raw_supply (regcache, i, NULL);
509 }
510
511 static void
512 core_files_info (struct target_ops *t)
513 {
514   print_section_info (t, core_bfd);
515 }
516 \f
517 static LONGEST
518 core_xfer_partial (struct target_ops *ops, enum target_object object,
519                    const char *annex, gdb_byte *readbuf,
520                    const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
521 {
522   switch (object)
523     {
524     case TARGET_OBJECT_MEMORY:
525       if (readbuf)
526         return (*ops->deprecated_xfer_memory) (offset, readbuf, len,
527                                                0/*write*/, NULL, ops);
528       if (writebuf)
529         return (*ops->deprecated_xfer_memory) (offset, readbuf, len,
530                                                1/*write*/, NULL, ops);
531       return -1;
532
533     case TARGET_OBJECT_AUXV:
534       if (readbuf)
535         {
536           /* When the aux vector is stored in core file, BFD
537              represents this with a fake section called ".auxv".  */
538
539           struct bfd_section *section;
540           bfd_size_type size;
541           char *contents;
542
543           section = bfd_get_section_by_name (core_bfd, ".auxv");
544           if (section == NULL)
545             return -1;
546
547           size = bfd_section_size (core_bfd, section);
548           if (offset >= size)
549             return 0;
550           size -= offset;
551           if (size > len)
552             size = len;
553           if (size > 0
554               && !bfd_get_section_contents (core_bfd, section, readbuf,
555                                             (file_ptr) offset, size))
556             {
557               warning (_("Couldn't read NT_AUXV note in core file."));
558               return -1;
559             }
560
561           return size;
562         }
563       return -1;
564
565     case TARGET_OBJECT_WCOOKIE:
566       if (readbuf)
567         {
568           /* When the StackGhost cookie is stored in core file, BFD
569              represents this with a fake section called ".wcookie".  */
570
571           struct bfd_section *section;
572           bfd_size_type size;
573           char *contents;
574
575           section = bfd_get_section_by_name (core_bfd, ".wcookie");
576           if (section == NULL)
577             return -1;
578
579           size = bfd_section_size (core_bfd, section);
580           if (offset >= size)
581             return 0;
582           size -= offset;
583           if (size > len)
584             size = len;
585           if (size > 0
586               && !bfd_get_section_contents (core_bfd, section, readbuf,
587                                             (file_ptr) offset, size))
588             {
589               warning (_("Couldn't read StackGhost cookie in core file."));
590               return -1;
591             }
592
593           return size;
594         }
595       return -1;
596
597     default:
598       if (ops->beneath != NULL)
599         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
600                                               readbuf, writebuf, offset, len);
601       return -1;
602     }
603 }
604
605 \f
606 /* If mourn is being called in all the right places, this could be say
607    `gdb internal error' (since generic_mourn calls breakpoint_init_inferior).  */
608
609 static int
610 ignore (struct bp_target_info *bp_tgt)
611 {
612   return 0;
613 }
614
615
616 /* Okay, let's be honest: threads gleaned from a core file aren't
617    exactly lively, are they?  On the other hand, if we don't claim
618    that each & every one is alive, then we don't get any of them
619    to appear in an "info thread" command, which is quite a useful
620    behaviour.
621  */
622 static int
623 core_file_thread_alive (ptid_t tid)
624 {
625   return 1;
626 }
627
628 /* Fill in core_ops with its defined operations and properties.  */
629
630 static void
631 init_core_ops (void)
632 {
633   core_ops.to_shortname = "core";
634   core_ops.to_longname = "Local core dump file";
635   core_ops.to_doc =
636     "Use a core file as a target.  Specify the filename of the core file.";
637   core_ops.to_open = core_open;
638   core_ops.to_close = core_close;
639   core_ops.to_attach = find_default_attach;
640   core_ops.to_detach = core_detach;
641   core_ops.to_fetch_registers = get_core_registers;
642   core_ops.to_xfer_partial = core_xfer_partial;
643   core_ops.deprecated_xfer_memory = xfer_memory;
644   core_ops.to_files_info = core_files_info;
645   core_ops.to_insert_breakpoint = ignore;
646   core_ops.to_remove_breakpoint = ignore;
647   core_ops.to_create_inferior = find_default_create_inferior;
648   core_ops.to_thread_alive = core_file_thread_alive;
649   core_ops.to_stratum = core_stratum;
650   core_ops.to_has_memory = 1;
651   core_ops.to_has_stack = 1;
652   core_ops.to_has_registers = 1;
653   core_ops.to_magic = OPS_MAGIC;
654 }
655
656 /* non-zero if we should not do the add_target call in
657    _initialize_corelow; not initialized (i.e., bss) so that
658    the target can initialize it (i.e., data) if appropriate.
659    This needs to be set at compile time because we don't know
660    for sure whether the target's initialize routine is called
661    before us or after us. */
662 int coreops_suppress_target;
663
664 void
665 _initialize_corelow (void)
666 {
667   init_core_ops ();
668
669   if (!coreops_suppress_target)
670     add_target (&core_ops);
671 }