1 /* Core dump and executable file functions below target vector, for GDB.
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.
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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
24 #include "gdb_string.h"
28 #ifdef HAVE_SYS_FILE_H
29 #include <sys/file.h> /* needed for F_OK and friends */
31 #include "frame.h" /* required by inferior.h */
38 #include "gdbthread.h"
43 #include "readline/readline.h"
44 #include "gdb_assert.h"
45 #include "exceptions.h"
53 /* List of all available core_fns. On gdb startup, each core file
54 register reader calls deprecated_add_core_fns() to register
55 information on each core format it is prepared to read. */
57 static struct core_fns
*core_file_fns
= NULL
;
59 /* The core_fns for a core file handler that is prepared to read the core
60 file currently open on core_bfd. */
62 static struct core_fns
*core_vec
= NULL
;
64 /* FIXME: kettenis/20031023: Eventually this variable should
67 struct gdbarch
*core_gdbarch
= NULL
;
69 static void core_files_info (struct target_ops
*);
71 static struct core_fns
*sniff_core_bfd (bfd
*);
73 static int gdb_check_format (bfd
*);
75 static void core_open (char *, int);
77 static void core_detach (char *, int);
79 static void core_close (int);
81 static void core_close_cleanup (void *ignore
);
83 static void get_core_registers (struct regcache
*, int);
85 static void add_to_thread_list (bfd
*, asection
*, void *);
87 static int core_file_thread_alive (ptid_t tid
);
89 static void init_core_ops (void);
91 void _initialize_corelow (void);
93 struct target_ops core_ops
;
95 /* Link a new core_fns into the global core_file_fns list. Called on gdb
96 startup by the _initialize routine in each core file register reader, to
97 register information about each format the the reader is prepared to
101 deprecated_add_core_fns (struct core_fns
*cf
)
103 cf
->next
= core_file_fns
;
107 /* The default function that core file handlers can use to examine a
108 core file BFD and decide whether or not to accept the job of
109 reading the core file. */
112 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
116 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
120 /* Walk through the list of core functions to find a set that can
121 handle the core file open on ABFD. Default to the first one in the
122 list if nothing matches. Returns pointer to set that is
125 static struct core_fns
*
126 sniff_core_bfd (bfd
*abfd
)
129 struct core_fns
*yummy
= NULL
;
132 /* Don't sniff if we have support for register sets in CORE_GDBARCH. */
133 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
136 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
138 if (cf
->core_sniffer (cf
, abfd
))
146 warning (_("\"%s\": ambiguous core format, %d handlers match"),
147 bfd_get_filename (abfd
), matches
);
149 else if (matches
== 0)
151 warning (_("\"%s\": no core file handler recognizes format, using default"),
152 bfd_get_filename (abfd
));
156 yummy
= core_file_fns
;
161 /* The default is to reject every core file format we see. Either
162 BFD has to recognize it, or we have to provide a function in the
163 core file handler that recognizes it. */
166 default_check_format (bfd
*abfd
)
171 /* Attempt to recognize core file formats that BFD rejects. */
174 gdb_check_format (bfd
*abfd
)
178 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
180 if (cf
->check_format (abfd
))
188 /* Discard all vestiges of any previous core file and mark data and stack
192 core_close (int quitting
)
198 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
200 /* Clear out solib state while the bfd is still open. See
201 comments in clear_solib in solib.c. */
208 name
= bfd_get_filename (core_bfd
);
209 if (!bfd_close (core_bfd
))
210 warning (_("cannot close \"%s\": %s"),
211 name
, bfd_errmsg (bfd_get_error ()));
214 if (core_ops
.to_sections
)
216 xfree (core_ops
.to_sections
);
217 core_ops
.to_sections
= NULL
;
218 core_ops
.to_sections_end
= NULL
;
226 core_close_cleanup (void *ignore
)
228 core_close (0/*ignored*/);
231 /* Look for sections whose names start with `.reg/' so that we can extract the
232 list of threads in a core file. */
235 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
238 asection
*reg_sect
= (asection
*) reg_sect_arg
;
240 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
243 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
245 add_thread (pid_to_ptid (thread_id
));
247 /* Warning, Will Robinson, looking at BFD private data! */
250 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
251 inferior_ptid
= pid_to_ptid (thread_id
); /* Yes, make it current */
254 /* This routine opens and sets up the core file bfd. */
257 core_open (char *filename
, int from_tty
)
261 struct cleanup
*old_chain
;
268 target_preopen (from_tty
);
272 error (_("No core file specified. (Use `detach' to stop debugging a core file.)"));
274 error (_("No core file specified."));
277 filename
= tilde_expand (filename
);
278 if (filename
[0] != '/')
280 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
285 old_chain
= make_cleanup (xfree
, filename
);
287 flags
= O_BINARY
| O_LARGEFILE
;
292 scratch_chan
= open (filename
, flags
, 0);
293 if (scratch_chan
< 0)
294 perror_with_name (filename
);
296 temp_bfd
= bfd_fopen (filename
, gnutarget
,
297 write_files
? FOPEN_RUB
: FOPEN_RB
,
299 if (temp_bfd
== NULL
)
300 perror_with_name (filename
);
302 if (!bfd_check_format (temp_bfd
, bfd_core
) &&
303 !gdb_check_format (temp_bfd
))
305 /* Do it after the err msg */
306 /* FIXME: should be checking for errors from bfd_close (for one thing,
307 on error it does not free all the storage associated with the
309 make_cleanup_bfd_close (temp_bfd
);
310 error (_("\"%s\" is not a core dump: %s"),
311 filename
, bfd_errmsg (bfd_get_error ()));
314 /* Looks semi-reasonable. Toss the old core file and work on the new. */
316 discard_cleanups (old_chain
); /* Don't free filename any more */
317 unpush_target (&core_ops
);
319 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
321 /* FIXME: kettenis/20031023: This is very dangerous. The
322 CORE_GDBARCH that results from this call may very well be
323 different from CURRENT_GDBARCH. However, its methods may only
324 work if it is selected as the current architecture, because they
325 rely on swapped data (see gdbarch.c). We should get rid of that
327 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
329 /* Find a suitable core file handler to munch on core_bfd */
330 core_vec
= sniff_core_bfd (core_bfd
);
334 /* Find the data section */
335 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
336 &core_ops
.to_sections_end
))
337 error (_("\"%s\": Can't find sections: %s"),
338 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
340 /* If we have no exec file, try to set the architecture from the
341 core file. We don't do this unconditionally since an exec file
342 typically contains more information that helps us determine the
343 architecture than a core file. */
345 set_gdbarch_from_file (core_bfd
);
347 ontop
= !push_target (&core_ops
);
348 discard_cleanups (old_chain
);
350 /* This is done first, before anything has a chance to query the
351 inferior for information such as symbols. */
352 post_create_inferior (&core_ops
, from_tty
);
354 p
= bfd_core_file_failing_command (core_bfd
);
356 printf_filtered (_("Core was generated by `%s'.\n"), p
);
358 siggy
= bfd_core_file_failing_signal (core_bfd
);
360 /* NOTE: target_signal_from_host() converts a target signal value
361 into gdb's internal signal value. Unfortunately gdb's internal
362 value is called ``target_signal'' and this function got the
363 name ..._from_host(). */
364 printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy
,
365 target_signal_to_string (target_signal_from_host (siggy
)));
367 /* Build up thread list from BFD sections. */
370 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
371 bfd_get_section_by_name (core_bfd
, ".reg"));
375 /* Fetch all registers from core file. */
376 target_fetch_registers (get_current_regcache (), -1);
378 /* Now, set up the frame cache, and print the top of stack. */
379 reinit_frame_cache ();
380 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
385 "you won't be able to access this core file until you terminate\n\
386 your %s; do ``info files''", target_longname
);
391 core_detach (char *args
, int from_tty
)
394 error (_("Too many arguments"));
395 unpush_target (&core_ops
);
396 reinit_frame_cache ();
398 printf_filtered (_("No core file now.\n"));
402 /* Try to retrieve registers from a section in core_bfd, and supply
403 them to core_vec->core_read_registers, as the register set numbered
406 If inferior_ptid is zero, do the single-threaded thing: look for a
407 section named NAME. If inferior_ptid is non-zero, do the
408 multi-threaded thing: look for a section named "NAME/PID", where
409 PID is the shortest ASCII decimal representation of inferior_ptid.
411 HUMAN_NAME is a human-readable name for the kind of registers the
412 NAME section contains, for use in error messages.
414 If REQUIRED is non-zero, print an error if the core file doesn't
415 have a section by the appropriate name. Otherwise, just do nothing. */
418 get_core_register_section (struct regcache
*regcache
,
424 static char *section_name
= NULL
;
425 struct bfd_section
*section
;
429 xfree (section_name
);
430 if (PIDGET (inferior_ptid
))
431 section_name
= xstrprintf ("%s/%d", name
, PIDGET (inferior_ptid
));
433 section_name
= xstrdup (name
);
435 section
= bfd_get_section_by_name (core_bfd
, section_name
);
439 warning (_("Couldn't find %s registers in core file."), human_name
);
443 size
= bfd_section_size (core_bfd
, section
);
444 contents
= alloca (size
);
445 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
448 warning (_("Couldn't read %s registers from `%s' section in core file."),
453 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
455 const struct regset
*regset
;
457 regset
= gdbarch_regset_from_core_section (core_gdbarch
, name
, size
);
461 warning (_("Couldn't recognize %s registers in core file."),
466 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
470 gdb_assert (core_vec
);
471 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
473 bfd_section_vma (core_bfd
, section
)));
477 /* Get the registers out of a core file. This is the machine-
478 independent part. Fetch_core_registers is the machine-dependent
479 part, typically implemented in the xm-file for each architecture. */
481 /* We just get all the registers, so we don't use regno. */
484 get_core_registers (struct regcache
*regcache
, int regno
)
488 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
489 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
491 fprintf_filtered (gdb_stderr
,
492 "Can't fetch registers from this type of core file\n");
496 get_core_register_section (regcache
,
497 ".reg", 0, "general-purpose", 1);
498 get_core_register_section (regcache
,
499 ".reg2", 2, "floating-point", 0);
500 get_core_register_section (regcache
,
501 ".reg-xfp", 3, "extended floating-point", 0);
503 /* Supply dummy value for all registers not found in the core. */
504 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
505 if (!regcache_valid_p (regcache
, i
))
506 regcache_raw_supply (regcache
, i
, NULL
);
510 core_files_info (struct target_ops
*t
)
512 print_section_info (t
, core_bfd
);
516 core_xfer_partial (struct target_ops
*ops
, enum target_object object
,
517 const char *annex
, gdb_byte
*readbuf
,
518 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
522 case TARGET_OBJECT_MEMORY
:
524 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
525 len
, 0/*write*/, NULL
, ops
);
527 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
528 len
, 1/*write*/, NULL
, ops
);
531 case TARGET_OBJECT_AUXV
:
534 /* When the aux vector is stored in core file, BFD
535 represents this with a fake section called ".auxv". */
537 struct bfd_section
*section
;
541 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
545 size
= bfd_section_size (core_bfd
, section
);
552 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
553 (file_ptr
) offset
, size
))
555 warning (_("Couldn't read NT_AUXV note in core file."));
563 case TARGET_OBJECT_WCOOKIE
:
566 /* When the StackGhost cookie is stored in core file, BFD
567 represents this with a fake section called ".wcookie". */
569 struct bfd_section
*section
;
573 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
577 size
= bfd_section_size (core_bfd
, section
);
584 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
585 (file_ptr
) offset
, size
))
587 warning (_("Couldn't read StackGhost cookie in core file."));
595 case TARGET_OBJECT_LIBRARIES
:
597 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch
))
602 gdbarch_core_xfer_shared_libraries (core_gdbarch
,
603 readbuf
, offset
, len
);
608 if (ops
->beneath
!= NULL
)
609 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
610 readbuf
, writebuf
, offset
, len
);
616 /* If mourn is being called in all the right places, this could be say
617 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
620 ignore (struct bp_target_info
*bp_tgt
)
626 /* Okay, let's be honest: threads gleaned from a core file aren't
627 exactly lively, are they? On the other hand, if we don't claim
628 that each & every one is alive, then we don't get any of them
629 to appear in an "info thread" command, which is quite a useful
633 core_file_thread_alive (ptid_t tid
)
638 /* Ask the current architecture what it knows about this core file.
639 That will be used, in turn, to pick a better architecture. This
640 wrapper could be avoided if targets got a chance to specialize
643 static const struct target_desc
*
644 core_read_description (struct target_ops
*target
)
646 if (gdbarch_core_read_description_p (current_gdbarch
))
647 return gdbarch_core_read_description (current_gdbarch
, target
, core_bfd
);
652 /* Fill in core_ops with its defined operations and properties. */
657 core_ops
.to_shortname
= "core";
658 core_ops
.to_longname
= "Local core dump file";
660 "Use a core file as a target. Specify the filename of the core file.";
661 core_ops
.to_open
= core_open
;
662 core_ops
.to_close
= core_close
;
663 core_ops
.to_attach
= find_default_attach
;
664 core_ops
.to_detach
= core_detach
;
665 core_ops
.to_fetch_registers
= get_core_registers
;
666 core_ops
.to_xfer_partial
= core_xfer_partial
;
667 core_ops
.deprecated_xfer_memory
= xfer_memory
;
668 core_ops
.to_files_info
= core_files_info
;
669 core_ops
.to_insert_breakpoint
= ignore
;
670 core_ops
.to_remove_breakpoint
= ignore
;
671 core_ops
.to_create_inferior
= find_default_create_inferior
;
672 core_ops
.to_thread_alive
= core_file_thread_alive
;
673 core_ops
.to_read_description
= core_read_description
;
674 core_ops
.to_stratum
= core_stratum
;
675 core_ops
.to_has_memory
= 1;
676 core_ops
.to_has_stack
= 1;
677 core_ops
.to_has_registers
= 1;
678 core_ops
.to_magic
= OPS_MAGIC
;
681 /* non-zero if we should not do the add_target call in
682 _initialize_corelow; not initialized (i.e., bss) so that
683 the target can initialize it (i.e., data) if appropriate.
684 This needs to be set at compile time because we don't know
685 for sure whether the target's initialize routine is called
686 before us or after us. */
687 int coreops_suppress_target
;
690 _initialize_corelow (void)
694 if (!coreops_suppress_target
)
695 add_target (&core_ops
);