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, 2008
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"
47 #include "filenames.h"
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. */
58 static struct core_fns
*core_file_fns
= NULL
;
60 /* The core_fns for a core file handler that is prepared to read the core
61 file currently open on core_bfd. */
63 static struct core_fns
*core_vec
= NULL
;
65 /* FIXME: kettenis/20031023: Eventually this variable should
68 struct gdbarch
*core_gdbarch
= NULL
;
70 static void core_files_info (struct target_ops
*);
72 static struct core_fns
*sniff_core_bfd (bfd
*);
74 static int gdb_check_format (bfd
*);
76 static void core_open (char *, int);
78 static void core_detach (char *, int);
80 static void core_close (int);
82 static void core_close_cleanup (void *ignore
);
84 static void get_core_registers (struct regcache
*, int);
86 static void add_to_thread_list (bfd
*, asection
*, void *);
88 static int core_file_thread_alive (ptid_t tid
);
90 static void init_core_ops (void);
92 void _initialize_corelow (void);
94 struct target_ops core_ops
;
96 /* Link a new core_fns into the global core_file_fns list. Called on gdb
97 startup by the _initialize routine in each core file register reader, to
98 register information about each format the the reader is prepared to
102 deprecated_add_core_fns (struct core_fns
*cf
)
104 cf
->next
= core_file_fns
;
108 /* The default function that core file handlers can use to examine a
109 core file BFD and decide whether or not to accept the job of
110 reading the core file. */
113 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
117 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
121 /* Walk through the list of core functions to find a set that can
122 handle the core file open on ABFD. Default to the first one in the
123 list if nothing matches. Returns pointer to set that is
126 static struct core_fns
*
127 sniff_core_bfd (bfd
*abfd
)
130 struct core_fns
*yummy
= NULL
;
133 /* Don't sniff if we have support for register sets in CORE_GDBARCH. */
134 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
137 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
139 if (cf
->core_sniffer (cf
, abfd
))
147 warning (_("\"%s\": ambiguous core format, %d handlers match"),
148 bfd_get_filename (abfd
), matches
);
150 else if (matches
== 0)
152 warning (_("\"%s\": no core file handler recognizes format, using default"),
153 bfd_get_filename (abfd
));
157 yummy
= core_file_fns
;
162 /* The default is to reject every core file format we see. Either
163 BFD has to recognize it, or we have to provide a function in the
164 core file handler that recognizes it. */
167 default_check_format (bfd
*abfd
)
172 /* Attempt to recognize core file formats that BFD rejects. */
175 gdb_check_format (bfd
*abfd
)
179 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
181 if (cf
->check_format (abfd
))
189 /* Discard all vestiges of any previous core file and mark data and stack
193 core_close (int quitting
)
199 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
201 /* Clear out solib state while the bfd is still open. See
202 comments in clear_solib in solib.c. */
205 name
= bfd_get_filename (core_bfd
);
206 if (!bfd_close (core_bfd
))
207 warning (_("cannot close \"%s\": %s"),
208 name
, bfd_errmsg (bfd_get_error ()));
211 if (core_ops
.to_sections
)
213 xfree (core_ops
.to_sections
);
214 core_ops
.to_sections
= NULL
;
215 core_ops
.to_sections_end
= NULL
;
223 core_close_cleanup (void *ignore
)
225 core_close (0/*ignored*/);
228 /* Look for sections whose names start with `.reg/' so that we can extract the
229 list of threads in a core file. */
232 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
235 asection
*reg_sect
= (asection
*) reg_sect_arg
;
237 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
240 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
242 add_thread (pid_to_ptid (thread_id
));
244 /* Warning, Will Robinson, looking at BFD private data! */
247 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
248 inferior_ptid
= pid_to_ptid (thread_id
); /* Yes, make it current */
251 /* This routine opens and sets up the core file bfd. */
254 core_open (char *filename
, int from_tty
)
258 struct cleanup
*old_chain
;
265 target_preopen (from_tty
);
269 error (_("No core file specified. (Use `detach' to stop debugging a core file.)"));
271 error (_("No core file specified."));
274 filename
= tilde_expand (filename
);
275 if (!IS_ABSOLUTE_PATH(filename
))
277 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
282 old_chain
= make_cleanup (xfree
, filename
);
284 flags
= O_BINARY
| O_LARGEFILE
;
289 scratch_chan
= open (filename
, flags
, 0);
290 if (scratch_chan
< 0)
291 perror_with_name (filename
);
293 temp_bfd
= bfd_fopen (filename
, gnutarget
,
294 write_files
? FOPEN_RUB
: FOPEN_RB
,
296 if (temp_bfd
== NULL
)
297 perror_with_name (filename
);
299 if (!bfd_check_format (temp_bfd
, bfd_core
) &&
300 !gdb_check_format (temp_bfd
))
302 /* Do it after the err msg */
303 /* FIXME: should be checking for errors from bfd_close (for one thing,
304 on error it does not free all the storage associated with the
306 make_cleanup_bfd_close (temp_bfd
);
307 error (_("\"%s\" is not a core dump: %s"),
308 filename
, bfd_errmsg (bfd_get_error ()));
311 /* Looks semi-reasonable. Toss the old core file and work on the new. */
313 discard_cleanups (old_chain
); /* Don't free filename any more */
314 unpush_target (&core_ops
);
316 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
318 /* FIXME: kettenis/20031023: This is very dangerous. The
319 CORE_GDBARCH that results from this call may very well be
320 different from CURRENT_GDBARCH. However, its methods may only
321 work if it is selected as the current architecture, because they
322 rely on swapped data (see gdbarch.c). We should get rid of that
324 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
326 /* Find a suitable core file handler to munch on core_bfd */
327 core_vec
= sniff_core_bfd (core_bfd
);
331 /* Find the data section */
332 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
333 &core_ops
.to_sections_end
))
334 error (_("\"%s\": Can't find sections: %s"),
335 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
337 /* If we have no exec file, try to set the architecture from the
338 core file. We don't do this unconditionally since an exec file
339 typically contains more information that helps us determine the
340 architecture than a core file. */
342 set_gdbarch_from_file (core_bfd
);
344 ontop
= !push_target (&core_ops
);
345 discard_cleanups (old_chain
);
347 /* This is done first, before anything has a chance to query the
348 inferior for information such as symbols. */
349 post_create_inferior (&core_ops
, from_tty
);
351 p
= bfd_core_file_failing_command (core_bfd
);
353 printf_filtered (_("Core was generated by `%s'.\n"), p
);
355 siggy
= bfd_core_file_failing_signal (core_bfd
);
357 /* NOTE: target_signal_from_host() converts a target signal value
358 into gdb's internal signal value. Unfortunately gdb's internal
359 value is called ``target_signal'' and this function got the
360 name ..._from_host(). */
361 printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy
,
362 target_signal_to_string (
363 gdbarch_target_signal_from_host (core_gdbarch
, siggy
)));
365 /* Build up thread list from BFD sections. */
368 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
369 bfd_get_section_by_name (core_bfd
, ".reg"));
373 /* Fetch all registers from core file. */
374 target_fetch_registers (get_current_regcache (), -1);
376 /* Now, set up the frame cache, and print the top of stack. */
377 reinit_frame_cache ();
378 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
383 "you won't be able to access this core file until you terminate\n\
384 your %s; do ``info files''", target_longname
);
389 core_detach (char *args
, int from_tty
)
392 error (_("Too many arguments"));
393 unpush_target (&core_ops
);
394 reinit_frame_cache ();
396 printf_filtered (_("No core file now.\n"));
400 /* Try to retrieve registers from a section in core_bfd, and supply
401 them to core_vec->core_read_registers, as the register set numbered
404 If inferior_ptid is zero, do the single-threaded thing: look for a
405 section named NAME. If inferior_ptid is non-zero, do the
406 multi-threaded thing: look for a section named "NAME/PID", where
407 PID is the shortest ASCII decimal representation of inferior_ptid.
409 HUMAN_NAME is a human-readable name for the kind of registers the
410 NAME section contains, for use in error messages.
412 If REQUIRED is non-zero, print an error if the core file doesn't
413 have a section by the appropriate name. Otherwise, just do nothing. */
416 get_core_register_section (struct regcache
*regcache
,
422 static char *section_name
= NULL
;
423 struct bfd_section
*section
;
427 xfree (section_name
);
428 if (PIDGET (inferior_ptid
))
429 section_name
= xstrprintf ("%s/%d", name
, PIDGET (inferior_ptid
));
431 section_name
= xstrdup (name
);
433 section
= bfd_get_section_by_name (core_bfd
, section_name
);
437 warning (_("Couldn't find %s registers in core file."), human_name
);
441 size
= bfd_section_size (core_bfd
, section
);
442 contents
= alloca (size
);
443 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
446 warning (_("Couldn't read %s registers from `%s' section in core file."),
451 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
453 const struct regset
*regset
;
455 regset
= gdbarch_regset_from_core_section (core_gdbarch
, name
, size
);
459 warning (_("Couldn't recognize %s registers in core file."),
464 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
468 gdb_assert (core_vec
);
469 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
471 bfd_section_vma (core_bfd
, section
)));
475 /* Get the registers out of a core file. This is the machine-
476 independent part. Fetch_core_registers is the machine-dependent
477 part, typically implemented in the xm-file for each architecture. */
479 /* We just get all the registers, so we don't use regno. */
482 get_core_registers (struct regcache
*regcache
, int regno
)
486 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
487 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
489 fprintf_filtered (gdb_stderr
,
490 "Can't fetch registers from this type of core file\n");
494 get_core_register_section (regcache
,
495 ".reg", 0, "general-purpose", 1);
496 get_core_register_section (regcache
,
497 ".reg2", 2, "floating-point", 0);
498 get_core_register_section (regcache
,
499 ".reg-xfp", 3, "extended floating-point", 0);
500 get_core_register_section (regcache
,
501 ".reg-ppc-vmx", 3, "ppc Altivec", 0);
503 /* Supply dummy value for all registers not found in the core. */
504 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); 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/*read*/, 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
);