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, 2009
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 (struct target_ops
*ops
, 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 /* An arbitrary identifier for the core inferior. */
99 /* Link a new core_fns into the global core_file_fns list. Called on gdb
100 startup by the _initialize routine in each core file register reader, to
101 register information about each format the the reader is prepared to
105 deprecated_add_core_fns (struct core_fns
*cf
)
107 cf
->next
= core_file_fns
;
111 /* The default function that core file handlers can use to examine a
112 core file BFD and decide whether or not to accept the job of
113 reading the core file. */
116 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
120 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
124 /* Walk through the list of core functions to find a set that can
125 handle the core file open on ABFD. Default to the first one in the
126 list if nothing matches. Returns pointer to set that is
129 static struct core_fns
*
130 sniff_core_bfd (bfd
*abfd
)
133 struct core_fns
*yummy
= NULL
;
136 /* Don't sniff if we have support for register sets in CORE_GDBARCH. */
137 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
140 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
142 if (cf
->core_sniffer (cf
, abfd
))
150 warning (_("\"%s\": ambiguous core format, %d handlers match"),
151 bfd_get_filename (abfd
), matches
);
153 else if (matches
== 0)
155 warning (_("\"%s\": no core file handler recognizes format, using default"),
156 bfd_get_filename (abfd
));
160 yummy
= core_file_fns
;
165 /* The default is to reject every core file format we see. Either
166 BFD has to recognize it, or we have to provide a function in the
167 core file handler that recognizes it. */
170 default_check_format (bfd
*abfd
)
175 /* Attempt to recognize core file formats that BFD rejects. */
178 gdb_check_format (bfd
*abfd
)
182 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
184 if (cf
->check_format (abfd
))
192 /* Discard all vestiges of any previous core file and mark data and stack
196 core_close (int quitting
)
202 int pid
= ptid_get_pid (inferior_ptid
);
203 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
204 delete_inferior_silent (pid
);
206 /* Clear out solib state while the bfd is still open. See
207 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
)
241 asection
*reg_sect
= (asection
*) reg_sect_arg
;
243 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
246 thread_id
= atoi (bfd_section_name (abfd
, asect
) + 5);
249 && gdbarch_core_reg_section_encodes_pid (core_gdbarch
))
251 uint32_t merged_pid
= thread_id
;
252 ptid
= ptid_build (merged_pid
& 0xffff,
253 merged_pid
>> 16, 0);
256 ptid
= ptid_build (ptid_get_pid (inferior_ptid
), thread_id
, 0);
258 if (ptid_get_lwp (inferior_ptid
) == 0)
259 /* The main thread has already been added before getting here, and
260 this is the first time we hear about a thread id. Assume this
261 is the main thread. */
262 thread_change_ptid (inferior_ptid
, ptid
);
264 /* Nope, really a new thread. */
267 /* Warning, Will Robinson, looking at BFD private data! */
270 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
271 inferior_ptid
= ptid
; /* Yes, make it current */
274 /* This routine opens and sets up the core file bfd. */
277 core_open (char *filename
, int from_tty
)
281 struct cleanup
*old_chain
;
286 int corelow_pid
= CORELOW_PID
;
288 target_preopen (from_tty
);
292 error (_("No core file specified. (Use `detach' to stop debugging a core file.)"));
294 error (_("No core file specified."));
297 filename
= tilde_expand (filename
);
298 if (!IS_ABSOLUTE_PATH(filename
))
300 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
305 old_chain
= make_cleanup (xfree
, filename
);
307 flags
= O_BINARY
| O_LARGEFILE
;
312 scratch_chan
= open (filename
, flags
, 0);
313 if (scratch_chan
< 0)
314 perror_with_name (filename
);
316 temp_bfd
= bfd_fopen (filename
, gnutarget
,
317 write_files
? FOPEN_RUB
: FOPEN_RB
,
319 if (temp_bfd
== NULL
)
320 perror_with_name (filename
);
322 if (!bfd_check_format (temp_bfd
, bfd_core
) &&
323 !gdb_check_format (temp_bfd
))
325 /* Do it after the err msg */
326 /* FIXME: should be checking for errors from bfd_close (for one thing,
327 on error it does not free all the storage associated with the
329 make_cleanup_bfd_close (temp_bfd
);
330 error (_("\"%s\" is not a core dump: %s"),
331 filename
, bfd_errmsg (bfd_get_error ()));
334 /* Looks semi-reasonable. Toss the old core file and work on the new. */
336 discard_cleanups (old_chain
); /* Don't free filename any more */
337 unpush_target (&core_ops
);
339 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
341 /* FIXME: kettenis/20031023: This is very dangerous. The
342 CORE_GDBARCH that results from this call may very well be
343 different from CURRENT_GDBARCH. However, its methods may only
344 work if it is selected as the current architecture, because they
345 rely on swapped data (see gdbarch.c). We should get rid of that
347 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
349 /* Find a suitable core file handler to munch on core_bfd */
350 core_vec
= sniff_core_bfd (core_bfd
);
354 /* Find the data section */
355 if (build_section_table (core_bfd
, &core_ops
.to_sections
,
356 &core_ops
.to_sections_end
))
357 error (_("\"%s\": Can't find sections: %s"),
358 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
360 /* If we have no exec file, try to set the architecture from the
361 core file. We don't do this unconditionally since an exec file
362 typically contains more information that helps us determine the
363 architecture than a core file. */
365 set_gdbarch_from_file (core_bfd
);
367 push_target (&core_ops
);
368 discard_cleanups (old_chain
);
370 add_inferior_silent (corelow_pid
);
372 /* Do this before acknowledging the inferior, so if
373 post_create_inferior throws (can happen easilly if you're loading
374 a core file with the wrong exec), we aren't left with threads
375 from the previous inferior. */
378 /* Set INFERIOR_PTID early, so an upper layer can rely on it being
379 set while in the target_find_new_threads call below. */
380 inferior_ptid
= pid_to_ptid (corelow_pid
);
382 /* Assume ST --- Add a main task. We'll later detect when we go
384 add_thread_silent (inferior_ptid
);
386 /* Build up thread list from BFD sections, and possibly set the
387 current thread to the .reg/NN section matching the .reg
389 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
390 bfd_get_section_by_name (core_bfd
, ".reg"));
392 post_create_inferior (&core_ops
, from_tty
);
394 /* Now go through the target stack looking for threads since there
395 may be a thread_stratum target loaded on top of target core by
396 now. The layer above should claim threads found in the BFD
398 target_find_new_threads ();
400 p
= bfd_core_file_failing_command (core_bfd
);
402 printf_filtered (_("Core was generated by `%s'.\n"), p
);
404 siggy
= bfd_core_file_failing_signal (core_bfd
);
406 /* NOTE: target_signal_from_host() converts a target signal value
407 into gdb's internal signal value. Unfortunately gdb's internal
408 value is called ``target_signal'' and this function got the
409 name ..._from_host(). */
410 printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy
,
411 target_signal_to_string (
412 gdbarch_target_signal_from_host (core_gdbarch
, siggy
)));
414 /* Fetch all registers from core file. */
415 target_fetch_registers (get_current_regcache (), -1);
417 /* Now, set up the frame cache, and print the top of stack. */
418 reinit_frame_cache ();
419 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
423 core_detach (struct target_ops
*ops
, char *args
, int from_tty
)
426 error (_("Too many arguments"));
428 reinit_frame_cache ();
430 printf_filtered (_("No core file now.\n"));
434 /* Try to retrieve registers from a section in core_bfd, and supply
435 them to core_vec->core_read_registers, as the register set numbered
438 If inferior_ptid's lwp member is zero, do the single-threaded
439 thing: look for a section named NAME. If inferior_ptid's lwp
440 member is non-zero, do the multi-threaded thing: look for a section
441 named "NAME/LWP", where LWP is the shortest ASCII decimal
442 representation of inferior_ptid's lwp member.
444 HUMAN_NAME is a human-readable name for the kind of registers the
445 NAME section contains, for use in error messages.
447 If REQUIRED is non-zero, print an error if the core file doesn't
448 have a section by the appropriate name. Otherwise, just do nothing. */
451 get_core_register_section (struct regcache
*regcache
,
457 static char *section_name
= NULL
;
458 struct bfd_section
*section
;
462 xfree (section_name
);
465 && gdbarch_core_reg_section_encodes_pid (core_gdbarch
))
469 merged_pid
= ptid_get_lwp (inferior_ptid
);
470 merged_pid
= merged_pid
<< 16 | ptid_get_pid (inferior_ptid
);
472 section_name
= xstrprintf ("%s/%s", name
, plongest (merged_pid
));
474 else if (ptid_get_lwp (inferior_ptid
))
475 section_name
= xstrprintf ("%s/%ld", name
, ptid_get_lwp (inferior_ptid
));
477 section_name
= xstrdup (name
);
479 section
= bfd_get_section_by_name (core_bfd
, section_name
);
483 warning (_("Couldn't find %s registers in core file."), human_name
);
487 size
= bfd_section_size (core_bfd
, section
);
488 contents
= alloca (size
);
489 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
492 warning (_("Couldn't read %s registers from `%s' section in core file."),
497 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
499 const struct regset
*regset
;
501 regset
= gdbarch_regset_from_core_section (core_gdbarch
, name
, size
);
505 warning (_("Couldn't recognize %s registers in core file."),
510 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
514 gdb_assert (core_vec
);
515 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
517 bfd_section_vma (core_bfd
, section
)));
521 /* Get the registers out of a core file. This is the machine-
522 independent part. Fetch_core_registers is the machine-dependent
523 part, typically implemented in the xm-file for each architecture. */
525 /* We just get all the registers, so we don't use regno. */
528 get_core_registers (struct regcache
*regcache
, int regno
)
532 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
533 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
535 fprintf_filtered (gdb_stderr
,
536 "Can't fetch registers from this type of core file\n");
540 get_core_register_section (regcache
,
541 ".reg", 0, "general-purpose", 1);
542 get_core_register_section (regcache
,
543 ".reg2", 2, "floating-point", 0);
544 get_core_register_section (regcache
,
545 ".reg-xfp", 3, "extended floating-point", 0);
546 get_core_register_section (regcache
,
547 ".reg-ppc-vmx", 3, "ppc Altivec", 0);
548 get_core_register_section (regcache
,
549 ".reg-ppc-vsx", 4, "POWER7 VSX", 0);
551 /* Supply dummy value for all registers not found in the core. */
552 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
553 if (!regcache_valid_p (regcache
, i
))
554 regcache_raw_supply (regcache
, i
, NULL
);
558 core_files_info (struct target_ops
*t
)
560 print_section_info (t
, core_bfd
);
564 core_xfer_partial (struct target_ops
*ops
, enum target_object object
,
565 const char *annex
, gdb_byte
*readbuf
,
566 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
570 case TARGET_OBJECT_MEMORY
:
572 return (*ops
->deprecated_xfer_memory
) (offset
, readbuf
,
573 len
, 0/*read*/, NULL
, ops
);
575 return (*ops
->deprecated_xfer_memory
) (offset
, (gdb_byte
*) writebuf
,
576 len
, 1/*write*/, NULL
, ops
);
579 case TARGET_OBJECT_AUXV
:
582 /* When the aux vector is stored in core file, BFD
583 represents this with a fake section called ".auxv". */
585 struct bfd_section
*section
;
589 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
593 size
= bfd_section_size (core_bfd
, section
);
600 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
601 (file_ptr
) offset
, size
))
603 warning (_("Couldn't read NT_AUXV note in core file."));
611 case TARGET_OBJECT_WCOOKIE
:
614 /* When the StackGhost cookie is stored in core file, BFD
615 represents this with a fake section called ".wcookie". */
617 struct bfd_section
*section
;
621 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
625 size
= bfd_section_size (core_bfd
, section
);
632 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
633 (file_ptr
) offset
, size
))
635 warning (_("Couldn't read StackGhost cookie in core file."));
643 case TARGET_OBJECT_LIBRARIES
:
645 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch
))
650 gdbarch_core_xfer_shared_libraries (core_gdbarch
,
651 readbuf
, offset
, len
);
656 if (ops
->beneath
!= NULL
)
657 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
658 readbuf
, writebuf
, offset
, len
);
664 /* If mourn is being called in all the right places, this could be say
665 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
668 ignore (struct bp_target_info
*bp_tgt
)
674 /* Okay, let's be honest: threads gleaned from a core file aren't
675 exactly lively, are they? On the other hand, if we don't claim
676 that each & every one is alive, then we don't get any of them
677 to appear in an "info thread" command, which is quite a useful
681 core_file_thread_alive (ptid_t tid
)
686 /* Ask the current architecture what it knows about this core file.
687 That will be used, in turn, to pick a better architecture. This
688 wrapper could be avoided if targets got a chance to specialize
691 static const struct target_desc
*
692 core_read_description (struct target_ops
*target
)
694 if (gdbarch_core_read_description_p (current_gdbarch
))
695 return gdbarch_core_read_description (current_gdbarch
, target
, core_bfd
);
701 core_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
705 if (ptid_get_lwp (ptid
) == 0)
706 xsnprintf (buf
, sizeof buf
, "<main task>");
708 xsnprintf (buf
, sizeof buf
, "Thread %ld", ptid_get_lwp (ptid
));
713 /* Fill in core_ops with its defined operations and properties. */
718 core_ops
.to_shortname
= "core";
719 core_ops
.to_longname
= "Local core dump file";
721 "Use a core file as a target. Specify the filename of the core file.";
722 core_ops
.to_open
= core_open
;
723 core_ops
.to_close
= core_close
;
724 core_ops
.to_attach
= find_default_attach
;
725 core_ops
.to_detach
= core_detach
;
726 core_ops
.to_fetch_registers
= get_core_registers
;
727 core_ops
.to_xfer_partial
= core_xfer_partial
;
728 core_ops
.deprecated_xfer_memory
= xfer_memory
;
729 core_ops
.to_files_info
= core_files_info
;
730 core_ops
.to_insert_breakpoint
= ignore
;
731 core_ops
.to_remove_breakpoint
= ignore
;
732 core_ops
.to_create_inferior
= find_default_create_inferior
;
733 core_ops
.to_thread_alive
= core_file_thread_alive
;
734 core_ops
.to_read_description
= core_read_description
;
735 core_ops
.to_pid_to_str
= core_pid_to_str
;
736 core_ops
.to_stratum
= core_stratum
;
737 core_ops
.to_has_memory
= 1;
738 core_ops
.to_has_stack
= 1;
739 core_ops
.to_has_registers
= 1;
740 core_ops
.to_magic
= OPS_MAGIC
;
743 /* non-zero if we should not do the add_target call in
744 _initialize_corelow; not initialized (i.e., bss) so that
745 the target can initialize it (i.e., data) if appropriate.
746 This needs to be set at compile time because we don't know
747 for sure whether the target's initialize routine is called
748 before us or after us. */
749 int coreops_suppress_target
;
752 _initialize_corelow (void)
756 if (!coreops_suppress_target
)
757 add_target (&core_ops
);