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
)
236 asection
*reg_sect
= (asection
*) reg_sect_arg
;
238 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
241 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
243 ptid
= ptid_build (ptid_get_pid (inferior_ptid
), thread_id
, 0);
245 if (ptid_get_lwp (inferior_ptid
) == 0)
246 /* The main thread has already been added before getting here, and
247 this is the first time we hear about a thread id. Assume this
248 is the main thread. */
249 thread_change_ptid (inferior_ptid
, ptid
);
251 /* Nope, really a new thread. */
254 /* Warning, Will Robinson, looking at BFD private data! */
257 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
258 inferior_ptid
= ptid
; /* Yes, make it current */
261 /* This routine opens and sets up the core file bfd. */
264 core_open (char *filename
, int from_tty
)
268 struct cleanup
*old_chain
;
273 /* An arbitrary identifier for the core inferior. */
276 target_preopen (from_tty
);
280 error (_("No core file specified. (Use `detach' to stop debugging a core file.)"));
282 error (_("No core file specified."));
285 filename
= tilde_expand (filename
);
286 if (!IS_ABSOLUTE_PATH(filename
))
288 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
293 old_chain
= make_cleanup (xfree
, filename
);
295 flags
= O_BINARY
| O_LARGEFILE
;
300 scratch_chan
= open (filename
, flags
, 0);
301 if (scratch_chan
< 0)
302 perror_with_name (filename
);
304 temp_bfd
= bfd_fopen (filename
, gnutarget
,
305 write_files
? FOPEN_RUB
: FOPEN_RB
,
307 if (temp_bfd
== NULL
)
308 perror_with_name (filename
);
310 if (!bfd_check_format (temp_bfd
, bfd_core
) &&
311 !gdb_check_format (temp_bfd
))
313 /* Do it after the err msg */
314 /* FIXME: should be checking for errors from bfd_close (for one thing,
315 on error it does not free all the storage associated with the
317 make_cleanup_bfd_close (temp_bfd
);
318 error (_("\"%s\" is not a core dump: %s"),
319 filename
, bfd_errmsg (bfd_get_error ()));
322 /* Looks semi-reasonable. Toss the old core file and work on the new. */
324 discard_cleanups (old_chain
); /* Don't free filename any more */
325 unpush_target (&core_ops
);
327 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
329 /* FIXME: kettenis/20031023: This is very dangerous. The
330 CORE_GDBARCH that results from this call may very well be
331 different from CURRENT_GDBARCH. However, its methods may only
332 work if it is selected as the current architecture, because they
333 rely on swapped data (see gdbarch.c). We should get rid of that
335 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
337 /* Find a suitable core file handler to munch on core_bfd */
338 core_vec
= sniff_core_bfd (core_bfd
);
342 /* Find the data section */
343 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
344 &core_ops
.to_sections_end
))
345 error (_("\"%s\": Can't find sections: %s"),
346 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
348 /* If we have no exec file, try to set the architecture from the
349 core file. We don't do this unconditionally since an exec file
350 typically contains more information that helps us determine the
351 architecture than a core file. */
353 set_gdbarch_from_file (core_bfd
);
355 push_target (&core_ops
);
356 discard_cleanups (old_chain
);
358 /* Do this before acknowledging the inferior, so if
359 post_create_inferior throws (can happen easilly if you're loading
360 a core file with the wrong exec), we aren't left with threads
361 from the previous inferior. */
364 /* Set INFERIOR_PTID early, so an upper layer can rely on it being
365 set while in the target_find_new_threads call below. */
366 inferior_ptid
= pid_to_ptid (corelow_pid
);
368 /* Assume ST --- Add a main task. We'll later detect when we go
370 add_thread_silent (inferior_ptid
);
372 /* This is done first, before anything has a chance to query the
373 inferior for information such as symbols. */
374 post_create_inferior (&core_ops
, from_tty
);
376 /* Build up thread list from BFD sections, and possibly set the
377 current thread to the .reg/NN section matching the .reg
379 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
380 bfd_get_section_by_name (core_bfd
, ".reg"));
382 /* Now go through the target stack looking for threads since there
383 may be a thread_stratum target loaded on top of target core by
384 now. The layer above should claim threads found in the BFD
386 target_find_new_threads ();
388 p
= bfd_core_file_failing_command (core_bfd
);
390 printf_filtered (_("Core was generated by `%s'.\n"), p
);
392 siggy
= bfd_core_file_failing_signal (core_bfd
);
394 /* NOTE: target_signal_from_host() converts a target signal value
395 into gdb's internal signal value. Unfortunately gdb's internal
396 value is called ``target_signal'' and this function got the
397 name ..._from_host(). */
398 printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy
,
399 target_signal_to_string (
400 gdbarch_target_signal_from_host (core_gdbarch
, siggy
)));
402 /* Fetch all registers from core file. */
403 target_fetch_registers (get_current_regcache (), -1);
405 /* Now, set up the frame cache, and print the top of stack. */
406 reinit_frame_cache ();
407 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
411 core_detach (char *args
, int from_tty
)
414 error (_("Too many arguments"));
415 unpush_target (&core_ops
);
416 reinit_frame_cache ();
418 printf_filtered (_("No core file now.\n"));
422 /* Try to retrieve registers from a section in core_bfd, and supply
423 them to core_vec->core_read_registers, as the register set numbered
426 If inferior_ptid's lwp member is zero, do the single-threaded
427 thing: look for a section named NAME. If inferior_ptid's lwp
428 member is non-zero, do the multi-threaded thing: look for a section
429 named "NAME/LWP", where LWP is the shortest ASCII decimal
430 representation of inferior_ptid's lwp member.
432 HUMAN_NAME is a human-readable name for the kind of registers the
433 NAME section contains, for use in error messages.
435 If REQUIRED is non-zero, print an error if the core file doesn't
436 have a section by the appropriate name. Otherwise, just do nothing. */
439 get_core_register_section (struct regcache
*regcache
,
445 static char *section_name
= NULL
;
446 struct bfd_section
*section
;
450 xfree (section_name
);
451 if (ptid_get_lwp (inferior_ptid
))
452 section_name
= xstrprintf ("%s/%ld", name
, ptid_get_lwp (inferior_ptid
));
454 section_name
= xstrdup (name
);
456 section
= bfd_get_section_by_name (core_bfd
, section_name
);
460 warning (_("Couldn't find %s registers in core file."), human_name
);
464 size
= bfd_section_size (core_bfd
, section
);
465 contents
= alloca (size
);
466 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
469 warning (_("Couldn't read %s registers from `%s' section in core file."),
474 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
476 const struct regset
*regset
;
478 regset
= gdbarch_regset_from_core_section (core_gdbarch
, name
, size
);
482 warning (_("Couldn't recognize %s registers in core file."),
487 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
491 gdb_assert (core_vec
);
492 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
494 bfd_section_vma (core_bfd
, section
)));
498 /* Get the registers out of a core file. This is the machine-
499 independent part. Fetch_core_registers is the machine-dependent
500 part, typically implemented in the xm-file for each architecture. */
502 /* We just get all the registers, so we don't use regno. */
505 get_core_registers (struct regcache
*regcache
, int regno
)
509 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
510 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
512 fprintf_filtered (gdb_stderr
,
513 "Can't fetch registers from this type of core file\n");
517 get_core_register_section (regcache
,
518 ".reg", 0, "general-purpose", 1);
519 get_core_register_section (regcache
,
520 ".reg2", 2, "floating-point", 0);
521 get_core_register_section (regcache
,
522 ".reg-xfp", 3, "extended floating-point", 0);
523 get_core_register_section (regcache
,
524 ".reg-ppc-vmx", 3, "ppc Altivec", 0);
525 get_core_register_section (regcache
,
526 ".reg-ppc-vsx", 4, "POWER7 VSX", 0);
528 /* Supply dummy value for all registers not found in the core. */
529 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
530 if (!regcache_valid_p (regcache
, i
))
531 regcache_raw_supply (regcache
, i
, NULL
);
535 core_files_info (struct target_ops
*t
)
537 print_section_info (t
, core_bfd
);
541 core_xfer_partial (struct target_ops
*ops
, enum target_object object
,
542 const char *annex
, gdb_byte
*readbuf
,
543 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
547 case TARGET_OBJECT_MEMORY
:
549 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
550 len
, 0/*read*/, NULL
, ops
);
552 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
553 len
, 1/*write*/, NULL
, ops
);
556 case TARGET_OBJECT_AUXV
:
559 /* When the aux vector is stored in core file, BFD
560 represents this with a fake section called ".auxv". */
562 struct bfd_section
*section
;
566 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
570 size
= bfd_section_size (core_bfd
, section
);
577 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
578 (file_ptr
) offset
, size
))
580 warning (_("Couldn't read NT_AUXV note in core file."));
588 case TARGET_OBJECT_WCOOKIE
:
591 /* When the StackGhost cookie is stored in core file, BFD
592 represents this with a fake section called ".wcookie". */
594 struct bfd_section
*section
;
598 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
602 size
= bfd_section_size (core_bfd
, section
);
609 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
610 (file_ptr
) offset
, size
))
612 warning (_("Couldn't read StackGhost cookie in core file."));
620 case TARGET_OBJECT_LIBRARIES
:
622 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch
))
627 gdbarch_core_xfer_shared_libraries (core_gdbarch
,
628 readbuf
, offset
, len
);
633 if (ops
->beneath
!= NULL
)
634 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
635 readbuf
, writebuf
, offset
, len
);
641 /* If mourn is being called in all the right places, this could be say
642 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
645 ignore (struct bp_target_info
*bp_tgt
)
651 /* Okay, let's be honest: threads gleaned from a core file aren't
652 exactly lively, are they? On the other hand, if we don't claim
653 that each & every one is alive, then we don't get any of them
654 to appear in an "info thread" command, which is quite a useful
658 core_file_thread_alive (ptid_t tid
)
663 /* Ask the current architecture what it knows about this core file.
664 That will be used, in turn, to pick a better architecture. This
665 wrapper could be avoided if targets got a chance to specialize
668 static const struct target_desc
*
669 core_read_description (struct target_ops
*target
)
671 if (gdbarch_core_read_description_p (current_gdbarch
))
672 return gdbarch_core_read_description (current_gdbarch
, target
, core_bfd
);
678 core_pid_to_str (ptid_t ptid
)
682 if (ptid_get_lwp (ptid
) == 0)
683 xsnprintf (buf
, sizeof buf
, "<main task>");
685 xsnprintf (buf
, sizeof buf
, "Thread %ld", ptid_get_lwp (ptid
));
690 /* Fill in core_ops with its defined operations and properties. */
695 core_ops
.to_shortname
= "core";
696 core_ops
.to_longname
= "Local core dump file";
698 "Use a core file as a target. Specify the filename of the core file.";
699 core_ops
.to_open
= core_open
;
700 core_ops
.to_close
= core_close
;
701 core_ops
.to_attach
= find_default_attach
;
702 core_ops
.to_detach
= core_detach
;
703 core_ops
.to_fetch_registers
= get_core_registers
;
704 core_ops
.to_xfer_partial
= core_xfer_partial
;
705 core_ops
.deprecated_xfer_memory
= xfer_memory
;
706 core_ops
.to_files_info
= core_files_info
;
707 core_ops
.to_insert_breakpoint
= ignore
;
708 core_ops
.to_remove_breakpoint
= ignore
;
709 core_ops
.to_create_inferior
= find_default_create_inferior
;
710 core_ops
.to_thread_alive
= core_file_thread_alive
;
711 core_ops
.to_read_description
= core_read_description
;
712 core_ops
.to_pid_to_str
= core_pid_to_str
;
713 core_ops
.to_stratum
= core_stratum
;
714 core_ops
.to_has_memory
= 1;
715 core_ops
.to_has_stack
= 1;
716 core_ops
.to_has_registers
= 1;
717 core_ops
.to_magic
= OPS_MAGIC
;
720 /* non-zero if we should not do the add_target call in
721 _initialize_corelow; not initialized (i.e., bss) so that
722 the target can initialize it (i.e., data) if appropriate.
723 This needs to be set at compile time because we don't know
724 for sure whether the target's initialize routine is called
725 before us or after us. */
726 int coreops_suppress_target
;
729 _initialize_corelow (void)
733 if (!coreops_suppress_target
)
734 add_target (&core_ops
);