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 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., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, 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"
46 #include "gdb_assert.h"
47 #include "exceptions.h"
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. */
59 static struct core_fns
*core_file_fns
= NULL
;
61 /* The core_fns for a core file handler that is prepared to read the core
62 file currently open on core_bfd. */
64 static struct core_fns
*core_vec
= NULL
;
66 /* FIXME: kettenis/20031023: Eventually this variable should
69 struct gdbarch
*core_gdbarch
= NULL
;
71 static void core_files_info (struct target_ops
*);
73 static struct core_fns
*sniff_core_bfd (bfd
*);
75 static int gdb_check_format (bfd
*);
77 static void core_open (char *, int);
79 static void core_detach (char *, int);
81 static void core_close (int);
83 static void core_close_cleanup (void *ignore
);
85 static void get_core_registers (struct regcache
*, int);
87 static void add_to_thread_list (bfd
*, asection
*, void *);
89 static int core_file_thread_alive (ptid_t tid
);
91 static void init_core_ops (void);
93 void _initialize_corelow (void);
95 struct target_ops core_ops
;
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
103 deprecated_add_core_fns (struct core_fns
*cf
)
105 cf
->next
= core_file_fns
;
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. */
114 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
118 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
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
127 static struct core_fns
*
128 sniff_core_bfd (bfd
*abfd
)
131 struct core_fns
*yummy
= NULL
;
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
))
138 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
140 if (cf
->core_sniffer (cf
, abfd
))
148 warning (_("\"%s\": ambiguous core format, %d handlers match"),
149 bfd_get_filename (abfd
), matches
);
151 else if (matches
== 0)
153 warning (_("\"%s\": no core file handler recognizes format, using default"),
154 bfd_get_filename (abfd
));
158 yummy
= core_file_fns
;
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. */
168 default_check_format (bfd
*abfd
)
173 /* Attempt to recognize core file formats that BFD rejects. */
176 gdb_check_format (bfd
*abfd
)
180 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
182 if (cf
->check_format (abfd
))
190 /* Discard all vestiges of any previous core file and mark data and stack
194 core_close (int quitting
)
200 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
202 /* Clear out solib state while the bfd is still open. See
203 comments in clear_solib in solib.c. */
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 ()));
216 if (core_ops
.to_sections
)
218 xfree (core_ops
.to_sections
);
219 core_ops
.to_sections
= NULL
;
220 core_ops
.to_sections_end
= NULL
;
228 core_close_cleanup (void *ignore
)
230 core_close (0/*ignored*/);
233 /* Look for sections whose names start with `.reg/' so that we can extract the
234 list of threads in a core file. */
237 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
240 asection
*reg_sect
= (asection
*) reg_sect_arg
;
242 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
245 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
247 add_thread (pid_to_ptid (thread_id
));
249 /* Warning, Will Robinson, looking at BFD private data! */
252 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
253 inferior_ptid
= pid_to_ptid (thread_id
); /* Yes, make it current */
256 /* This routine opens and sets up the core file bfd. */
259 core_open (char *filename
, int from_tty
)
263 struct cleanup
*old_chain
;
270 target_preopen (from_tty
);
274 error (_("No core file specified. (Use `detach' to stop debugging a core file.)"));
276 error (_("No core file specified."));
279 filename
= tilde_expand (filename
);
280 if (filename
[0] != '/')
282 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
287 old_chain
= make_cleanup (xfree
, filename
);
289 flags
= O_BINARY
| O_LARGEFILE
;
294 scratch_chan
= open (filename
, flags
, 0);
295 if (scratch_chan
< 0)
296 perror_with_name (filename
);
298 temp_bfd
= bfd_fopen (filename
, gnutarget
,
299 write_files
? FOPEN_RUB
: FOPEN_RB
,
301 if (temp_bfd
== NULL
)
302 perror_with_name (filename
);
304 if (!bfd_check_format (temp_bfd
, bfd_core
) &&
305 !gdb_check_format (temp_bfd
))
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
311 make_cleanup_bfd_close (temp_bfd
);
312 error (_("\"%s\" is not a core dump: %s"),
313 filename
, bfd_errmsg (bfd_get_error ()));
316 /* Looks semi-reasonable. Toss the old core file and work on the new. */
318 discard_cleanups (old_chain
); /* Don't free filename any more */
319 unpush_target (&core_ops
);
321 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
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
329 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
331 /* Find a suitable core file handler to munch on core_bfd */
332 core_vec
= sniff_core_bfd (core_bfd
);
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 ()));
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. */
347 set_gdbarch_from_file (core_bfd
);
349 ontop
= !push_target (&core_ops
);
350 discard_cleanups (old_chain
);
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
);
356 p
= bfd_core_file_failing_command (core_bfd
);
358 printf_filtered (_("Core was generated by `%s'.\n"), p
);
360 siggy
= bfd_core_file_failing_signal (core_bfd
);
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
)));
369 /* Build up thread list from BFD sections. */
372 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
373 bfd_get_section_by_name (core_bfd
, ".reg"));
377 /* Fetch all registers from core file. */
378 target_fetch_registers (current_regcache
, -1);
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
);
387 "you won't be able to access this core file until you terminate\n\
388 your %s; do ``info files''", target_longname
);
393 core_detach (char *args
, int from_tty
)
396 error (_("Too many arguments"));
397 unpush_target (&core_ops
);
398 reinit_frame_cache ();
400 printf_filtered (_("No core file now.\n"));
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
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.
413 HUMAN_NAME is a human-readable name for the kind of registers the
414 NAME section contains, for use in error messages.
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. */
420 get_core_register_section (struct regcache
*regcache
,
426 static char *section_name
= NULL
;
427 struct bfd_section
*section
;
431 xfree (section_name
);
432 if (PIDGET (inferior_ptid
))
433 section_name
= xstrprintf ("%s/%d", name
, PIDGET (inferior_ptid
));
435 section_name
= xstrdup (name
);
437 section
= bfd_get_section_by_name (core_bfd
, section_name
);
441 warning (_("Couldn't find %s registers in core file."), human_name
);
445 size
= bfd_section_size (core_bfd
, section
);
446 contents
= alloca (size
);
447 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
450 warning (_("Couldn't read %s registers from `%s' section in core file."),
455 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
457 const struct regset
*regset
;
459 regset
= gdbarch_regset_from_core_section (core_gdbarch
, name
, size
);
463 warning (_("Couldn't recognize %s registers in core file."),
468 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
472 gdb_assert (core_vec
);
473 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
475 bfd_section_vma (core_bfd
, section
)));
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. */
483 /* We just get all the registers, so we don't use regno. */
486 get_core_registers (struct regcache
*regcache
, int regno
)
490 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
491 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
493 fprintf_filtered (gdb_stderr
,
494 "Can't fetch registers from this type of core file\n");
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);
505 /* Supply dummy value for all registers not found in the core. */
506 for (i
= 0; i
< NUM_REGS
; i
++)
507 if (!regcache_valid_p (regcache
, i
))
508 regcache_raw_supply (regcache
, i
, NULL
);
512 core_files_info (struct target_ops
*t
)
514 print_section_info (t
, core_bfd
);
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
)
524 case TARGET_OBJECT_MEMORY
:
526 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
, len
,
527 0/*write*/, NULL
, ops
);
529 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
, len
,
530 1/*write*/, NULL
, ops
);
533 case TARGET_OBJECT_AUXV
:
536 /* When the aux vector is stored in core file, BFD
537 represents this with a fake section called ".auxv". */
539 struct bfd_section
*section
;
543 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
547 size
= bfd_section_size (core_bfd
, section
);
554 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
555 (file_ptr
) offset
, size
))
557 warning (_("Couldn't read NT_AUXV note in core file."));
565 case TARGET_OBJECT_WCOOKIE
:
568 /* When the StackGhost cookie is stored in core file, BFD
569 represents this with a fake section called ".wcookie". */
571 struct bfd_section
*section
;
575 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
579 size
= bfd_section_size (core_bfd
, section
);
586 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
587 (file_ptr
) offset
, size
))
589 warning (_("Couldn't read StackGhost cookie in core file."));
598 if (ops
->beneath
!= NULL
)
599 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
600 readbuf
, writebuf
, offset
, len
);
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). */
610 ignore (struct bp_target_info
*bp_tgt
)
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
623 core_file_thread_alive (ptid_t tid
)
628 /* Fill in core_ops with its defined operations and properties. */
633 core_ops
.to_shortname
= "core";
634 core_ops
.to_longname
= "Local core dump file";
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
;
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
;
665 _initialize_corelow (void)
669 if (!coreops_suppress_target
)
670 add_target (&core_ops
);