1 /* Core dump and executable file functions below target vector, for GDB.
3 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software Foundation,
7 This file is part of GDB.
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.
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.
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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "arch-utils.h"
26 #include "gdb_string.h"
30 #ifdef HAVE_SYS_FILE_H
31 #include <sys/file.h> /* needed for F_OK and friends */
33 #include "frame.h" /* required by inferior.h */
40 #include "gdbthread.h"
45 #include "readline/readline.h"
47 #include "gdb_assert.h"
48 #include "exceptions.h"
58 /* List of all available core_fns. On gdb startup, each core file
59 register reader calls deprecated_add_core_fns() to register
60 information on each core format it is prepared to read. */
62 static struct core_fns
*core_file_fns
= NULL
;
64 /* The core_fns for a core file handler that is prepared to read the core
65 file currently open on core_bfd. */
67 static struct core_fns
*core_vec
= NULL
;
69 /* FIXME: kettenis/20031023: Eventually this variable should
72 struct gdbarch
*core_gdbarch
= NULL
;
74 static void core_files_info (struct target_ops
*);
77 static int solib_add_stub (void *);
80 static struct core_fns
*sniff_core_bfd (bfd
*);
82 static int gdb_check_format (bfd
*);
84 static void core_open (char *, int);
86 static void core_detach (char *, int);
88 static void core_close (int);
90 static void core_close_cleanup (void *ignore
);
92 static void get_core_registers (int);
94 static void add_to_thread_list (bfd
*, asection
*, void *);
96 static int ignore (CORE_ADDR
, char *);
98 static int core_file_thread_alive (ptid_t tid
);
100 static void init_core_ops (void);
102 void _initialize_corelow (void);
104 struct target_ops core_ops
;
106 /* Link a new core_fns into the global core_file_fns list. Called on gdb
107 startup by the _initialize routine in each core file register reader, to
108 register information about each format the the reader is prepared to
112 deprecated_add_core_fns (struct core_fns
*cf
)
114 cf
->next
= core_file_fns
;
118 /* The default function that core file handlers can use to examine a
119 core file BFD and decide whether or not to accept the job of
120 reading the core file. */
123 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
127 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
131 /* Walk through the list of core functions to find a set that can
132 handle the core file open on ABFD. Default to the first one in the
133 list if nothing matches. Returns pointer to set that is
136 static struct core_fns
*
137 sniff_core_bfd (bfd
*abfd
)
140 struct core_fns
*yummy
= NULL
;
143 /* Don't sniff if we have support for register sets in CORE_GDBARCH. */
144 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
147 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
149 if (cf
->core_sniffer (cf
, abfd
))
157 warning ("\"%s\": ambiguous core format, %d handlers match",
158 bfd_get_filename (abfd
), matches
);
160 else if (matches
== 0)
162 warning ("\"%s\": no core file handler recognizes format, using default",
163 bfd_get_filename (abfd
));
167 yummy
= core_file_fns
;
172 /* The default is to reject every core file format we see. Either
173 BFD has to recognize it, or we have to provide a function in the
174 core file handler that recognizes it. */
177 default_check_format (bfd
*abfd
)
182 /* Attempt to recognize core file formats that BFD rejects. */
185 gdb_check_format (bfd
*abfd
)
189 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
191 if (cf
->check_format (abfd
))
199 /* Discard all vestiges of any previous core file and mark data and stack
203 core_close (int quitting
)
209 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
211 /* Clear out solib state while the bfd is still open. See
212 comments in clear_solib in solib.c. */
217 name
= bfd_get_filename (core_bfd
);
218 if (!bfd_close (core_bfd
))
219 warning ("cannot close \"%s\": %s",
220 name
, bfd_errmsg (bfd_get_error ()));
223 if (core_ops
.to_sections
)
225 xfree (core_ops
.to_sections
);
226 core_ops
.to_sections
= NULL
;
227 core_ops
.to_sections_end
= NULL
;
235 core_close_cleanup (void *ignore
)
237 core_close (0/*ignored*/);
241 /* Stub function for catch_errors around shared library hacking. FROM_TTYP
242 is really an int * which points to from_tty. */
245 solib_add_stub (void *from_ttyp
)
247 SOLIB_ADD (NULL
, *(int *) from_ttyp
, ¤t_target
, auto_solib_add
);
248 re_enable_breakpoints_in_shlibs ();
251 #endif /* SOLIB_ADD */
253 /* Look for sections whose names start with `.reg/' so that we can extract the
254 list of threads in a core file. */
257 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
260 asection
*reg_sect
= (asection
*) reg_sect_arg
;
262 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
265 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
267 add_thread (pid_to_ptid (thread_id
));
269 /* Warning, Will Robinson, looking at BFD private data! */
272 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
273 inferior_ptid
= pid_to_ptid (thread_id
); /* Yes, make it current */
276 /* This routine opens and sets up the core file bfd. */
279 core_open (char *filename
, int from_tty
)
283 struct cleanup
*old_chain
;
290 target_preopen (from_tty
);
294 "No core file specified. (Use `detach' to stop debugging a core file.)"
295 : "No core file specified.");
298 filename
= tilde_expand (filename
);
299 if (filename
[0] != '/')
301 temp
= concat (current_directory
, "/", filename
, NULL
);
306 old_chain
= make_cleanup (xfree
, filename
);
308 flags
= O_BINARY
| O_LARGEFILE
;
313 scratch_chan
= open (filename
, flags
, 0);
314 if (scratch_chan
< 0)
315 perror_with_name (filename
);
317 temp_bfd
= bfd_fdopenr (filename
, gnutarget
, scratch_chan
);
318 if (temp_bfd
== NULL
)
319 perror_with_name (filename
);
321 if (!bfd_check_format (temp_bfd
, bfd_core
) &&
322 !gdb_check_format (temp_bfd
))
324 /* Do it after the err msg */
325 /* FIXME: should be checking for errors from bfd_close (for one thing,
326 on error it does not free all the storage associated with the
328 make_cleanup_bfd_close (temp_bfd
);
329 error ("\"%s\" is not a core dump: %s",
330 filename
, bfd_errmsg (bfd_get_error ()));
333 /* Looks semi-reasonable. Toss the old core file and work on the new. */
335 discard_cleanups (old_chain
); /* Don't free filename any more */
336 unpush_target (&core_ops
);
338 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
340 /* FIXME: kettenis/20031023: This is very dangerous. The
341 CORE_GDBARCH that results from this call may very well be
342 different from CURRENT_GDBARCH. However, its methods may only
343 work if it is selected as the current architecture, because they
344 rely on swapped data (see gdbarch.c). We should get rid of that
346 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
348 /* Find a suitable core file handler to munch on core_bfd */
349 core_vec
= sniff_core_bfd (core_bfd
);
353 /* Find the data section */
354 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
355 &core_ops
.to_sections_end
))
356 error ("\"%s\": Can't find sections: %s",
357 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
359 /* If we have no exec file, try to set the architecture from the
360 core file. We don't do this unconditionally since an exec file
361 typically contains more information that helps us determine the
362 architecture than a core file. */
364 set_gdbarch_from_file (core_bfd
);
366 ontop
= !push_target (&core_ops
);
367 discard_cleanups (old_chain
);
369 /* This is done first, before anything has a chance to query the
370 inferior for information such as symbols. */
371 observer_notify_inferior_created (&core_ops
, from_tty
);
373 p
= bfd_core_file_failing_command (core_bfd
);
375 printf_filtered ("Core was generated by `%s'.\n", p
);
377 siggy
= bfd_core_file_failing_signal (core_bfd
);
379 /* NOTE: target_signal_from_host() converts a target signal value
380 into gdb's internal signal value. Unfortunately gdb's internal
381 value is called ``target_signal'' and this function got the
382 name ..._from_host(). */
383 printf_filtered ("Program terminated with signal %d, %s.\n", siggy
,
384 target_signal_to_string (target_signal_from_host (siggy
)));
386 /* Build up thread list from BFD sections. */
389 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
390 bfd_get_section_by_name (core_bfd
, ".reg"));
394 /* Fetch all registers from core file. */
395 target_fetch_registers (-1);
397 /* Add symbols and section mappings for any shared libraries. */
399 catch_errors (solib_add_stub
, &from_tty
, (char *) 0,
403 /* Now, set up the frame cache, and print the top of stack. */
404 flush_cached_frames ();
405 select_frame (get_current_frame ());
406 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
411 "you won't be able to access this core file until you terminate\n\
412 your %s; do ``info files''", target_longname
);
417 core_detach (char *args
, int from_tty
)
420 error ("Too many arguments");
421 unpush_target (&core_ops
);
422 reinit_frame_cache ();
424 printf_filtered ("No core file now.\n");
428 /* Try to retrieve registers from a section in core_bfd, and supply
429 them to core_vec->core_read_registers, as the register set numbered
432 If inferior_ptid is zero, do the single-threaded thing: look for a
433 section named NAME. If inferior_ptid is non-zero, do the
434 multi-threaded thing: look for a section named "NAME/PID", where
435 PID is the shortest ASCII decimal representation of inferior_ptid.
437 HUMAN_NAME is a human-readable name for the kind of registers the
438 NAME section contains, for use in error messages.
440 If REQUIRED is non-zero, print an error if the core file doesn't
441 have a section by the appropriate name. Otherwise, just do nothing. */
444 get_core_register_section (char *name
,
449 char section_name
[100];
450 struct bfd_section
*section
;
454 if (PIDGET (inferior_ptid
))
455 sprintf (section_name
, "%s/%d", name
, PIDGET (inferior_ptid
));
457 strcpy (section_name
, name
);
459 section
= bfd_get_section_by_name (core_bfd
, section_name
);
463 warning ("Couldn't find %s registers in core file.\n", human_name
);
467 size
= bfd_section_size (core_bfd
, section
);
468 contents
= alloca (size
);
469 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
472 warning ("Couldn't read %s registers from `%s' section in core file.\n",
477 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
479 const struct regset
*regset
;
481 regset
= gdbarch_regset_from_core_section (core_gdbarch
, name
, size
);
485 warning ("Couldn't recognize %s registers in core file.\n",
490 regset
->supply_regset (regset
, current_regcache
, -1, contents
, size
);
494 gdb_assert (core_vec
);
495 core_vec
->core_read_registers (contents
, size
, which
,
497 bfd_section_vma (core_bfd
, section
)));
501 /* Get the registers out of a core file. This is the machine-
502 independent part. Fetch_core_registers is the machine-dependent
503 part, typically implemented in the xm-file for each architecture. */
505 /* We just get all the registers, so we don't use regno. */
508 get_core_registers (int regno
)
512 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
513 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
515 fprintf_filtered (gdb_stderr
,
516 "Can't fetch registers from this type of core file\n");
520 get_core_register_section (".reg", 0, "general-purpose", 1);
521 get_core_register_section (".reg2", 2, "floating-point", 0);
522 get_core_register_section (".reg-xfp", 3, "extended floating-point", 0);
524 deprecated_registers_fetched ();
528 core_files_info (struct target_ops
*t
)
530 print_section_info (t
, core_bfd
);
534 core_xfer_partial (struct target_ops
*ops
, enum target_object object
,
535 const char *annex
, void *readbuf
,
536 const void *writebuf
, ULONGEST offset
, LONGEST len
)
540 case TARGET_OBJECT_MEMORY
:
542 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
, len
,
543 0/*write*/, NULL
, ops
);
545 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
, len
,
546 1/*write*/, NULL
, ops
);
549 case TARGET_OBJECT_AUXV
:
552 /* When the aux vector is stored in core file, BFD
553 represents this with a fake section called ".auxv". */
555 struct bfd_section
*section
;
559 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
563 size
= bfd_section_size (core_bfd
, section
);
570 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
571 (file_ptr
) offset
, size
))
573 warning ("Couldn't read NT_AUXV note in core file.");
581 case TARGET_OBJECT_WCOOKIE
:
584 /* When the StackGhost cookie is stored in core file, BFD
585 represents this with a fake section called ".wcookie". */
587 struct bfd_section
*section
;
591 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
595 size
= bfd_section_size (core_bfd
, section
);
602 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
603 (file_ptr
) offset
, size
))
605 warning ("Couldn't read StackGhost cookie in core file.");
614 if (ops
->beneath
!= NULL
)
615 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
616 readbuf
, writebuf
, offset
, len
);
622 /* If mourn is being called in all the right places, this could be say
623 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
626 ignore (CORE_ADDR addr
, char *contents
)
632 /* Okay, let's be honest: threads gleaned from a core file aren't
633 exactly lively, are they? On the other hand, if we don't claim
634 that each & every one is alive, then we don't get any of them
635 to appear in an "info thread" command, which is quite a useful
639 core_file_thread_alive (ptid_t tid
)
644 /* Fill in core_ops with its defined operations and properties. */
649 core_ops
.to_shortname
= "core";
650 core_ops
.to_longname
= "Local core dump file";
652 "Use a core file as a target. Specify the filename of the core file.";
653 core_ops
.to_open
= core_open
;
654 core_ops
.to_close
= core_close
;
655 core_ops
.to_attach
= find_default_attach
;
656 core_ops
.to_detach
= core_detach
;
657 core_ops
.to_fetch_registers
= get_core_registers
;
658 core_ops
.to_xfer_partial
= core_xfer_partial
;
659 core_ops
.deprecated_xfer_memory
= xfer_memory
;
660 core_ops
.to_files_info
= core_files_info
;
661 core_ops
.to_insert_breakpoint
= ignore
;
662 core_ops
.to_remove_breakpoint
= ignore
;
663 core_ops
.to_create_inferior
= find_default_create_inferior
;
664 core_ops
.to_thread_alive
= core_file_thread_alive
;
665 core_ops
.to_stratum
= core_stratum
;
666 core_ops
.to_has_memory
= 1;
667 core_ops
.to_has_stack
= 1;
668 core_ops
.to_has_registers
= 1;
669 core_ops
.to_magic
= OPS_MAGIC
;
672 /* non-zero if we should not do the add_target call in
673 _initialize_corelow; not initialized (i.e., bss) so that
674 the target can initialize it (i.e., data) if appropriate.
675 This needs to be set at compile time because we don't know
676 for sure whether the target's initialize routine is called
677 before us or after us. */
678 int coreops_suppress_target
;
681 _initialize_corelow (void)
685 if (!coreops_suppress_target
)
686 add_target (&core_ops
);