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, 2010
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"
48 #include "progspace.h"
56 /* List of all available core_fns. On gdb startup, each core file
57 register reader calls deprecated_add_core_fns() to register
58 information on each core format it is prepared to read. */
60 static struct core_fns
*core_file_fns
= NULL
;
62 /* The core_fns for a core file handler that is prepared to read the core
63 file currently open on core_bfd. */
65 static struct core_fns
*core_vec
= NULL
;
67 /* FIXME: kettenis/20031023: Eventually this variable should
70 struct gdbarch
*core_gdbarch
= NULL
;
72 /* Per-core data. Currently, only the section table. Note that these
73 target sections are *not* mapped in the current address spaces' set
74 of target sections --- those should come only from pure executable
75 or shared library bfds. The core bfd sections are an
76 implementation detail of the core target, just like ptrace is for
77 unix child targets. */
78 static struct target_section_table
*core_data
;
80 /* True if we needed to fake the pid of the loaded core inferior. */
81 static int core_has_fake_pid
= 0;
83 static void core_files_info (struct target_ops
*);
85 static struct core_fns
*sniff_core_bfd (bfd
*);
87 static int gdb_check_format (bfd
*);
89 static void core_open (char *, int);
91 static void core_detach (struct target_ops
*ops
, char *, int);
93 static void core_close (int);
95 static void core_close_cleanup (void *ignore
);
97 static void add_to_thread_list (bfd
*, asection
*, void *);
99 static void init_core_ops (void);
101 void _initialize_corelow (void);
103 struct target_ops core_ops
;
105 /* An arbitrary identifier for the core inferior. */
106 #define CORELOW_PID 1
108 /* Link a new core_fns into the global core_file_fns list. Called on gdb
109 startup by the _initialize routine in each core file register reader, to
110 register information about each format the the reader is prepared to
114 deprecated_add_core_fns (struct core_fns
*cf
)
116 cf
->next
= core_file_fns
;
120 /* The default function that core file handlers can use to examine a
121 core file BFD and decide whether or not to accept the job of
122 reading the core file. */
125 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
129 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
133 /* Walk through the list of core functions to find a set that can
134 handle the core file open on ABFD. Default to the first one in the
135 list if nothing matches. Returns pointer to set that is
138 static struct core_fns
*
139 sniff_core_bfd (bfd
*abfd
)
142 struct core_fns
*yummy
= NULL
;
145 /* Don't sniff if we have support for register sets in CORE_GDBARCH. */
146 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
149 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
151 if (cf
->core_sniffer (cf
, abfd
))
159 warning (_("\"%s\": ambiguous core format, %d handlers match"),
160 bfd_get_filename (abfd
), matches
);
162 else if (matches
== 0)
164 warning (_("\"%s\": no core file handler recognizes format, using default"),
165 bfd_get_filename (abfd
));
169 yummy
= core_file_fns
;
174 /* The default is to reject every core file format we see. Either
175 BFD has to recognize it, or we have to provide a function in the
176 core file handler that recognizes it. */
179 default_check_format (bfd
*abfd
)
184 /* Attempt to recognize core file formats that BFD rejects. */
187 gdb_check_format (bfd
*abfd
)
191 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
193 if (cf
->check_format (abfd
))
201 /* Discard all vestiges of any previous core file and mark data and stack
205 core_close (int quitting
)
211 int pid
= ptid_get_pid (inferior_ptid
);
212 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
213 exit_inferior_silent (pid
);
215 /* Clear out solib state while the bfd is still open. See
216 comments in clear_solib in solib.c. */
219 xfree (core_data
->sections
);
222 core_has_fake_pid
= 0;
224 name
= bfd_get_filename (core_bfd
);
225 gdb_bfd_close_or_warn (core_bfd
);
234 core_close_cleanup (void *ignore
)
236 core_close (0/*ignored*/);
239 /* Look for sections whose names start with `.reg/' so that we can extract the
240 list of threads in a core file. */
243 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
248 asection
*reg_sect
= (asection
*) reg_sect_arg
;
250 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
253 core_tid
= atoi (bfd_section_name (abfd
, asect
) + 5);
256 && gdbarch_core_reg_section_encodes_pid (core_gdbarch
))
258 uint32_t merged_pid
= core_tid
;
259 pid
= merged_pid
& 0xffff;
260 lwpid
= merged_pid
>> 16;
262 /* This can happen on solaris core, for example, if we don't
263 find a NT_PSTATUS note in the core, but do find NT_LWPSTATUS
267 core_has_fake_pid
= 1;
273 core_has_fake_pid
= 1;
278 if (current_inferior ()->pid
== 0)
279 inferior_appeared (current_inferior (), pid
);
281 ptid
= ptid_build (pid
, lwpid
, 0);
285 /* Warning, Will Robinson, looking at BFD private data! */
288 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
289 inferior_ptid
= ptid
; /* Yes, make it current */
292 /* This routine opens and sets up the core file bfd. */
295 core_open (char *filename
, int from_tty
)
299 struct cleanup
*old_chain
;
305 target_preopen (from_tty
);
309 error (_("No core file specified. (Use `detach' to stop debugging a core file.)"));
311 error (_("No core file specified."));
314 filename
= tilde_expand (filename
);
315 if (!IS_ABSOLUTE_PATH(filename
))
317 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
322 old_chain
= make_cleanup (xfree
, filename
);
324 flags
= O_BINARY
| O_LARGEFILE
;
329 scratch_chan
= open (filename
, flags
, 0);
330 if (scratch_chan
< 0)
331 perror_with_name (filename
);
333 temp_bfd
= bfd_fopen (filename
, gnutarget
,
334 write_files
? FOPEN_RUB
: FOPEN_RB
,
336 if (temp_bfd
== NULL
)
337 perror_with_name (filename
);
339 if (!bfd_check_format (temp_bfd
, bfd_core
)
340 && !gdb_check_format (temp_bfd
))
342 /* Do it after the err msg */
343 /* FIXME: should be checking for errors from bfd_close (for one thing,
344 on error it does not free all the storage associated with the
346 make_cleanup_bfd_close (temp_bfd
);
347 error (_("\"%s\" is not a core dump: %s"),
348 filename
, bfd_errmsg (bfd_get_error ()));
351 /* Looks semi-reasonable. Toss the old core file and work on the new. */
353 discard_cleanups (old_chain
); /* Don't free filename any more */
354 unpush_target (&core_ops
);
356 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
358 /* FIXME: kettenis/20031023: This is very dangerous. The
359 CORE_GDBARCH that results from this call may very well be
360 different from CURRENT_GDBARCH. However, its methods may only
361 work if it is selected as the current architecture, because they
362 rely on swapped data (see gdbarch.c). We should get rid of that
364 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
366 /* Find a suitable core file handler to munch on core_bfd */
367 core_vec
= sniff_core_bfd (core_bfd
);
371 core_data
= XZALLOC (struct target_section_table
);
373 /* Find the data section */
374 if (build_section_table (core_bfd
,
375 &core_data
->sections
, &core_data
->sections_end
))
376 error (_("\"%s\": Can't find sections: %s"),
377 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
379 /* If we have no exec file, try to set the architecture from the
380 core file. We don't do this unconditionally since an exec file
381 typically contains more information that helps us determine the
382 architecture than a core file. */
384 set_gdbarch_from_file (core_bfd
);
386 push_target (&core_ops
);
387 discard_cleanups (old_chain
);
389 /* Do this before acknowledging the inferior, so if
390 post_create_inferior throws (can happen easilly if you're loading
391 a core file with the wrong exec), we aren't left with threads
392 from the previous inferior. */
395 inferior_ptid
= null_ptid
;
396 core_has_fake_pid
= 0;
398 /* Need to flush the register cache (and the frame cache) from a
399 previous debug session. If inferior_ptid ends up the same as the
400 last debug session --- e.g., b foo; run; gcore core1; step; gcore
401 core2; core core1; core core2 --- then there's potential for
402 get_current_regcache to return the cached regcache of the
403 previous session, and the frame cache being stale. */
404 registers_changed ();
406 /* Build up thread list from BFD sections, and possibly set the
407 current thread to the .reg/NN section matching the .reg
409 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
410 bfd_get_section_by_name (core_bfd
, ".reg"));
412 if (ptid_equal (inferior_ptid
, null_ptid
))
414 /* Either we found no .reg/NN section, and hence we have a
415 non-threaded core (single-threaded, from gdb's perspective),
416 or for some reason add_to_thread_list couldn't determine
417 which was the "main" thread. The latter case shouldn't
418 usually happen, but we're dealing with input here, which can
419 always be broken in different ways. */
420 struct thread_info
*thread
= first_thread_of_process (-1);
423 inferior_appeared (current_inferior (), CORELOW_PID
);
424 inferior_ptid
= pid_to_ptid (CORELOW_PID
);
425 add_thread_silent (inferior_ptid
);
428 switch_to_thread (thread
->ptid
);
431 post_create_inferior (&core_ops
, from_tty
);
433 /* Now go through the target stack looking for threads since there
434 may be a thread_stratum target loaded on top of target core by
435 now. The layer above should claim threads found in the BFD
437 target_find_new_threads ();
439 p
= bfd_core_file_failing_command (core_bfd
);
441 printf_filtered (_("Core was generated by `%s'.\n"), p
);
443 siggy
= bfd_core_file_failing_signal (core_bfd
);
445 /* NOTE: target_signal_from_host() converts a target signal value
446 into gdb's internal signal value. Unfortunately gdb's internal
447 value is called ``target_signal'' and this function got the
448 name ..._from_host(). */
449 printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy
,
450 target_signal_to_string (
451 (core_gdbarch
!= NULL
) ?
452 gdbarch_target_signal_from_host (core_gdbarch
, siggy
)
455 /* Fetch all registers from core file. */
456 target_fetch_registers (get_current_regcache (), -1);
458 /* Now, set up the frame cache, and print the top of stack. */
459 reinit_frame_cache ();
460 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
464 core_detach (struct target_ops
*ops
, char *args
, int from_tty
)
467 error (_("Too many arguments"));
469 reinit_frame_cache ();
471 printf_filtered (_("No core file now.\n"));
474 #ifdef DEPRECATED_IBM6000_TARGET
476 /* Resize the core memory's section table, by NUM_ADDED. Returns a
477 pointer into the first new slot. This will not be necessary when
478 the rs6000 target is converted to use the standard solib
481 struct target_section
*
482 deprecated_core_resize_section_table (int num_added
)
486 old_count
= resize_section_table (core_data
, num_added
);
487 return core_data
->sections
+ old_count
;
492 /* Try to retrieve registers from a section in core_bfd, and supply
493 them to core_vec->core_read_registers, as the register set numbered
496 If inferior_ptid's lwp member is zero, do the single-threaded
497 thing: look for a section named NAME. If inferior_ptid's lwp
498 member is non-zero, do the multi-threaded thing: look for a section
499 named "NAME/LWP", where LWP is the shortest ASCII decimal
500 representation of inferior_ptid's lwp member.
502 HUMAN_NAME is a human-readable name for the kind of registers the
503 NAME section contains, for use in error messages.
505 If REQUIRED is non-zero, print an error if the core file doesn't
506 have a section by the appropriate name. Otherwise, just do nothing. */
509 get_core_register_section (struct regcache
*regcache
,
512 const char *human_name
,
515 static char *section_name
= NULL
;
516 struct bfd_section
*section
;
520 xfree (section_name
);
523 && gdbarch_core_reg_section_encodes_pid (core_gdbarch
))
526 int pid
= ptid_get_pid (inferior_ptid
);
528 if (core_has_fake_pid
)
531 merged_pid
= ptid_get_lwp (inferior_ptid
);
532 merged_pid
= merged_pid
<< 16 | pid
;
534 section_name
= xstrprintf ("%s/%s", name
, plongest (merged_pid
));
536 else if (ptid_get_lwp (inferior_ptid
))
537 section_name
= xstrprintf ("%s/%ld", name
, ptid_get_lwp (inferior_ptid
));
539 section_name
= xstrdup (name
);
541 section
= bfd_get_section_by_name (core_bfd
, section_name
);
545 warning (_("Couldn't find %s registers in core file."), human_name
);
549 size
= bfd_section_size (core_bfd
, section
);
550 contents
= alloca (size
);
551 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
554 warning (_("Couldn't read %s registers from `%s' section in core file."),
559 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
561 const struct regset
*regset
;
563 regset
= gdbarch_regset_from_core_section (core_gdbarch
, name
, size
);
567 warning (_("Couldn't recognize %s registers in core file."),
572 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
576 gdb_assert (core_vec
);
577 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
579 bfd_section_vma (core_bfd
, section
)));
583 /* Get the registers out of a core file. This is the machine-
584 independent part. Fetch_core_registers is the machine-dependent
585 part, typically implemented in the xm-file for each architecture. */
587 /* We just get all the registers, so we don't use regno. */
590 get_core_registers (struct target_ops
*ops
,
591 struct regcache
*regcache
, int regno
)
593 struct core_regset_section
*sect_list
;
596 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
597 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
599 fprintf_filtered (gdb_stderr
,
600 "Can't fetch registers from this type of core file\n");
604 sect_list
= gdbarch_core_regset_sections (get_regcache_arch (regcache
));
606 while (sect_list
->sect_name
!= NULL
)
608 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
609 get_core_register_section (regcache
, sect_list
->sect_name
,
610 0, sect_list
->human_name
, 1);
611 else if (strcmp (sect_list
->sect_name
, ".reg2") == 0)
612 get_core_register_section (regcache
, sect_list
->sect_name
,
613 2, sect_list
->human_name
, 0);
615 get_core_register_section (regcache
, sect_list
->sect_name
,
616 3, sect_list
->human_name
, 0);
623 get_core_register_section (regcache
,
624 ".reg", 0, "general-purpose", 1);
625 get_core_register_section (regcache
,
626 ".reg2", 2, "floating-point", 0);
629 /* Supply dummy value for all registers not found in the core. */
630 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
631 if (!regcache_valid_p (regcache
, i
))
632 regcache_raw_supply (regcache
, i
, NULL
);
636 core_files_info (struct target_ops
*t
)
638 print_section_info (core_data
, core_bfd
);
651 add_to_spuid_list (bfd
*abfd
, asection
*asect
, void *list_p
)
653 struct spuid_list
*list
= list_p
;
654 enum bfd_endian byte_order
655 = bfd_big_endian (abfd
)? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
658 sscanf (bfd_section_name (abfd
, asect
), "SPU/%d/regs%n", &fd
, &pos
);
662 if (list
->pos
>= list
->offset
&& list
->pos
+ 4 <= list
->offset
+ list
->len
)
664 store_unsigned_integer (list
->buf
+ list
->pos
- list
->offset
,
672 core_xfer_partial (struct target_ops
*ops
, enum target_object object
,
673 const char *annex
, gdb_byte
*readbuf
,
674 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
678 case TARGET_OBJECT_MEMORY
:
679 return section_table_xfer_memory_partial (readbuf
, writebuf
,
682 core_data
->sections_end
,
685 case TARGET_OBJECT_AUXV
:
688 /* When the aux vector is stored in core file, BFD
689 represents this with a fake section called ".auxv". */
691 struct bfd_section
*section
;
695 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
699 size
= bfd_section_size (core_bfd
, section
);
706 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
707 (file_ptr
) offset
, size
))
709 warning (_("Couldn't read NT_AUXV note in core file."));
717 case TARGET_OBJECT_WCOOKIE
:
720 /* When the StackGhost cookie is stored in core file, BFD
721 represents this with a fake section called ".wcookie". */
723 struct bfd_section
*section
;
727 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
731 size
= bfd_section_size (core_bfd
, section
);
738 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
739 (file_ptr
) offset
, size
))
741 warning (_("Couldn't read StackGhost cookie in core file."));
749 case TARGET_OBJECT_LIBRARIES
:
751 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch
))
756 gdbarch_core_xfer_shared_libraries (core_gdbarch
,
757 readbuf
, offset
, len
);
761 case TARGET_OBJECT_SPU
:
762 if (readbuf
&& annex
)
764 /* When the SPU contexts are stored in a core file, BFD
765 represents this with a fake section called "SPU/<annex>". */
767 struct bfd_section
*section
;
771 char sectionstr
[100];
772 xsnprintf (sectionstr
, sizeof sectionstr
, "SPU/%s", annex
);
774 section
= bfd_get_section_by_name (core_bfd
, sectionstr
);
778 size
= bfd_section_size (core_bfd
, section
);
785 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
786 (file_ptr
) offset
, size
))
788 warning (_("Couldn't read SPU section in core file."));
796 /* NULL annex requests list of all present spuids. */
797 struct spuid_list list
;
799 list
.offset
= offset
;
803 bfd_map_over_sections (core_bfd
, add_to_spuid_list
, &list
);
809 if (ops
->beneath
!= NULL
)
810 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
811 readbuf
, writebuf
, offset
, len
);
817 /* If mourn is being called in all the right places, this could be say
818 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
821 ignore (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
827 /* Okay, let's be honest: threads gleaned from a core file aren't
828 exactly lively, are they? On the other hand, if we don't claim
829 that each & every one is alive, then we don't get any of them
830 to appear in an "info thread" command, which is quite a useful
834 core_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
839 /* Ask the current architecture what it knows about this core file.
840 That will be used, in turn, to pick a better architecture. This
841 wrapper could be avoided if targets got a chance to specialize
844 static const struct target_desc
*
845 core_read_description (struct target_ops
*target
)
847 if (core_gdbarch
&& gdbarch_core_read_description_p (core_gdbarch
))
848 return gdbarch_core_read_description (core_gdbarch
, target
, core_bfd
);
854 core_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
859 && gdbarch_core_pid_to_str_p (core_gdbarch
))
861 char *ret
= gdbarch_core_pid_to_str (core_gdbarch
, ptid
);
866 if (ptid_get_lwp (ptid
) == 0)
867 xsnprintf (buf
, sizeof buf
, "<main task>");
869 xsnprintf (buf
, sizeof buf
, "Thread %ld", ptid_get_lwp (ptid
));
875 core_has_memory (struct target_ops
*ops
)
877 return (core_bfd
!= NULL
);
881 core_has_stack (struct target_ops
*ops
)
883 return (core_bfd
!= NULL
);
887 core_has_registers (struct target_ops
*ops
)
889 return (core_bfd
!= NULL
);
892 /* Fill in core_ops with its defined operations and properties. */
897 core_ops
.to_shortname
= "core";
898 core_ops
.to_longname
= "Local core dump file";
900 "Use a core file as a target. Specify the filename of the core file.";
901 core_ops
.to_open
= core_open
;
902 core_ops
.to_close
= core_close
;
903 core_ops
.to_attach
= find_default_attach
;
904 core_ops
.to_detach
= core_detach
;
905 core_ops
.to_fetch_registers
= get_core_registers
;
906 core_ops
.to_xfer_partial
= core_xfer_partial
;
907 core_ops
.to_files_info
= core_files_info
;
908 core_ops
.to_insert_breakpoint
= ignore
;
909 core_ops
.to_remove_breakpoint
= ignore
;
910 core_ops
.to_create_inferior
= find_default_create_inferior
;
911 core_ops
.to_thread_alive
= core_thread_alive
;
912 core_ops
.to_read_description
= core_read_description
;
913 core_ops
.to_pid_to_str
= core_pid_to_str
;
914 core_ops
.to_stratum
= core_stratum
;
915 core_ops
.to_has_memory
= core_has_memory
;
916 core_ops
.to_has_stack
= core_has_stack
;
917 core_ops
.to_has_registers
= core_has_registers
;
918 core_ops
.to_magic
= OPS_MAGIC
;
922 _initialize_corelow (void)
926 add_target (&core_ops
);