1 /* Core dump and executable file functions below target vector, for GDB.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
22 #include "gdb_string.h"
26 #ifdef HAVE_SYS_FILE_H
27 #include <sys/file.h> /* needed for F_OK and friends */
29 #include "frame.h" /* required by inferior.h */
36 #include "gdbthread.h"
41 #include "readline/readline.h"
42 #include "gdb_assert.h"
43 #include "exceptions.h"
45 #include "filenames.h"
46 #include "progspace.h"
49 #include "completer.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
62 core 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 /* Per-core data. Currently, only the section table. Note that these
72 target sections are *not* mapped in the current address spaces' set
73 of target sections --- those should come only from pure executable
74 or shared library bfds. The core bfd sections are an
75 implementation detail of the core target, just like ptrace is for
76 unix child targets. */
77 static struct target_section_table
*core_data
;
79 static void core_files_info (struct target_ops
*);
81 static struct core_fns
*sniff_core_bfd (bfd
*);
83 static int gdb_check_format (bfd
*);
85 static void core_open (char *, int);
87 static void core_detach (struct target_ops
*ops
, char *, int);
89 static void core_close (void);
91 static void core_close_cleanup (void *ignore
);
93 static void add_to_thread_list (bfd
*, asection
*, void *);
95 static void init_core_ops (void);
97 void _initialize_corelow (void);
99 static struct target_ops core_ops
;
101 /* An arbitrary identifier for the core inferior. */
102 #define CORELOW_PID 1
104 /* Link a new core_fns into the global core_file_fns list. Called on
105 gdb startup by the _initialize routine in each core file register
106 reader, to register information about each format the reader is
107 prepared to handle. */
110 deprecated_add_core_fns (struct core_fns
*cf
)
112 cf
->next
= core_file_fns
;
116 /* The default function that core file handlers can use to examine a
117 core file BFD and decide whether or not to accept the job of
118 reading the core file. */
121 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
125 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
129 /* Walk through the list of core functions to find a set that can
130 handle the core file open on ABFD. Returns pointer to set that is
133 static struct core_fns
*
134 sniff_core_bfd (bfd
*abfd
)
137 struct core_fns
*yummy
= NULL
;
140 /* Don't sniff if we have support for register sets in
142 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
145 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
147 if (cf
->core_sniffer (cf
, abfd
))
155 warning (_("\"%s\": ambiguous core format, %d handlers match"),
156 bfd_get_filename (abfd
), matches
);
158 else if (matches
== 0)
159 error (_("\"%s\": no core file handler recognizes format"),
160 bfd_get_filename (abfd
));
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
193 stack spaces as empty. */
200 int pid
= ptid_get_pid (inferior_ptid
);
201 inferior_ptid
= null_ptid
; /* Avoid confusion from thread
204 exit_inferior_silent (pid
);
206 /* Clear out solib state while the bfd is still open. See
207 comments in clear_solib in solib.c. */
212 xfree (core_data
->sections
);
217 gdb_bfd_unref (core_bfd
);
225 core_close_cleanup (void *ignore
)
230 /* Look for sections whose names start with `.reg/' so that we can
231 extract the list of threads in a core file. */
234 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
239 asection
*reg_sect
= (asection
*) reg_sect_arg
;
241 struct inferior
*inf
;
243 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
246 core_tid
= atoi (bfd_section_name (abfd
, asect
) + 5);
248 pid
= bfd_core_file_pid (core_bfd
);
257 inf
= current_inferior ();
260 inferior_appeared (inf
, pid
);
261 inf
->fake_pid_p
= fake_pid_p
;
264 ptid
= ptid_build (pid
, lwpid
, 0);
268 /* Warning, Will Robinson, looking at BFD private data! */
271 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
272 inferior_ptid
= ptid
; /* Yes, make it current. */
275 /* This routine opens and sets up the core file bfd. */
278 core_open (char *filename
, int from_tty
)
282 struct cleanup
*old_chain
;
287 volatile struct gdb_exception except
;
289 target_preopen (from_tty
);
293 error (_("No core file specified. (Use `detach' "
294 "to stop debugging a core file.)"));
296 error (_("No core file specified."));
299 filename
= tilde_expand (filename
);
300 if (!IS_ABSOLUTE_PATH (filename
))
302 temp
= concat (current_directory
, "/",
303 filename
, (char *) NULL
);
308 old_chain
= make_cleanup (xfree
, filename
);
310 flags
= O_BINARY
| O_LARGEFILE
;
315 scratch_chan
= open (filename
, flags
, 0);
316 if (scratch_chan
< 0)
317 perror_with_name (filename
);
319 temp_bfd
= gdb_bfd_fopen (filename
, gnutarget
,
320 write_files
? FOPEN_RUB
: FOPEN_RB
,
322 if (temp_bfd
== NULL
)
323 perror_with_name (filename
);
325 if (!bfd_check_format (temp_bfd
, bfd_core
)
326 && !gdb_check_format (temp_bfd
))
328 /* Do it after the err msg */
329 /* FIXME: should be checking for errors from bfd_close (for one
330 thing, on error it does not free all the storage associated
332 make_cleanup_bfd_unref (temp_bfd
);
333 error (_("\"%s\" is not a core dump: %s"),
334 filename
, bfd_errmsg (bfd_get_error ()));
337 /* Looks semi-reasonable. Toss the old core file and work on the
340 do_cleanups (old_chain
);
341 unpush_target (&core_ops
);
343 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
345 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
347 /* Find a suitable core file handler to munch on core_bfd */
348 core_vec
= sniff_core_bfd (core_bfd
);
352 core_data
= XZALLOC (struct target_section_table
);
354 /* Find the data section */
355 if (build_section_table (core_bfd
,
356 &core_data
->sections
,
357 &core_data
->sections_end
))
358 error (_("\"%s\": Can't find sections: %s"),
359 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
361 /* If we have no exec file, try to set the architecture from the
362 core file. We don't do this unconditionally since an exec file
363 typically contains more information that helps us determine the
364 architecture than a core file. */
366 set_gdbarch_from_file (core_bfd
);
368 push_target (&core_ops
);
369 discard_cleanups (old_chain
);
371 /* Do this before acknowledging the inferior, so if
372 post_create_inferior throws (can happen easilly if you're loading
373 a core file with the wrong exec), we aren't left with threads
374 from the previous inferior. */
377 inferior_ptid
= null_ptid
;
379 /* Need to flush the register cache (and the frame cache) from a
380 previous debug session. If inferior_ptid ends up the same as the
381 last debug session --- e.g., b foo; run; gcore core1; step; gcore
382 core2; core core1; core core2 --- then there's potential for
383 get_current_regcache to return the cached regcache of the
384 previous session, and the frame cache being stale. */
385 registers_changed ();
387 /* Build up thread list from BFD sections, and possibly set the
388 current thread to the .reg/NN section matching the .reg
390 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
391 bfd_get_section_by_name (core_bfd
, ".reg"));
393 if (ptid_equal (inferior_ptid
, null_ptid
))
395 /* Either we found no .reg/NN section, and hence we have a
396 non-threaded core (single-threaded, from gdb's perspective),
397 or for some reason add_to_thread_list couldn't determine
398 which was the "main" thread. The latter case shouldn't
399 usually happen, but we're dealing with input here, which can
400 always be broken in different ways. */
401 struct thread_info
*thread
= first_thread_of_process (-1);
405 inferior_appeared (current_inferior (), CORELOW_PID
);
406 inferior_ptid
= pid_to_ptid (CORELOW_PID
);
407 add_thread_silent (inferior_ptid
);
410 switch_to_thread (thread
->ptid
);
413 post_create_inferior (&core_ops
, from_tty
);
415 /* Now go through the target stack looking for threads since there
416 may be a thread_stratum target loaded on top of target core by
417 now. The layer above should claim threads found in the BFD
419 TRY_CATCH (except
, RETURN_MASK_ERROR
)
421 target_find_new_threads ();
424 if (except
.reason
< 0)
425 exception_print (gdb_stderr
, except
);
427 p
= bfd_core_file_failing_command (core_bfd
);
429 printf_filtered (_("Core was generated by `%s'.\n"), p
);
431 siggy
= bfd_core_file_failing_signal (core_bfd
);
434 /* If we don't have a CORE_GDBARCH to work with, assume a native
435 core (map gdb_signal from host signals). If we do have
436 CORE_GDBARCH to work with, but no gdb_signal_from_target
437 implementation for that gdbarch, as a fallback measure,
438 assume the host signal mapping. It'll be correct for native
439 cores, but most likely incorrect for cross-cores. */
440 enum gdb_signal sig
= (core_gdbarch
!= NULL
441 && gdbarch_gdb_signal_from_target_p (core_gdbarch
)
442 ? gdbarch_gdb_signal_from_target (core_gdbarch
,
444 : gdb_signal_from_host (siggy
));
446 printf_filtered (_("Program terminated with signal %d, %s.\n"),
447 siggy
, gdb_signal_to_string (sig
));
450 /* Fetch all registers from core file. */
451 target_fetch_registers (get_current_regcache (), -1);
453 /* Now, set up the frame cache, and print the top of stack. */
454 reinit_frame_cache ();
455 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
459 core_detach (struct target_ops
*ops
, char *args
, int from_tty
)
462 error (_("Too many arguments"));
464 reinit_frame_cache ();
466 printf_filtered (_("No core file now.\n"));
469 #ifdef DEPRECATED_IBM6000_TARGET
471 /* Resize the core memory's section table, by NUM_ADDED. Returns a
472 pointer into the first new slot. This will not be necessary when
473 the rs6000 target is converted to use the standard solib
476 struct target_section
*
477 deprecated_core_resize_section_table (int num_added
)
481 old_count
= resize_section_table (core_data
, num_added
);
482 return core_data
->sections
+ old_count
;
487 /* Try to retrieve registers from a section in core_bfd, and supply
488 them to core_vec->core_read_registers, as the register set numbered
491 If inferior_ptid's lwp member is zero, do the single-threaded
492 thing: look for a section named NAME. If inferior_ptid's lwp
493 member is non-zero, do the multi-threaded thing: look for a section
494 named "NAME/LWP", where LWP is the shortest ASCII decimal
495 representation of inferior_ptid's lwp member.
497 HUMAN_NAME is a human-readable name for the kind of registers the
498 NAME section contains, for use in error messages.
500 If REQUIRED is non-zero, print an error if the core file doesn't
501 have a section by the appropriate name. Otherwise, just do
505 get_core_register_section (struct regcache
*regcache
,
508 const char *human_name
,
511 static char *section_name
= NULL
;
512 struct bfd_section
*section
;
516 xfree (section_name
);
518 if (ptid_get_lwp (inferior_ptid
))
519 section_name
= xstrprintf ("%s/%ld", name
,
520 ptid_get_lwp (inferior_ptid
));
522 section_name
= xstrdup (name
);
524 section
= bfd_get_section_by_name (core_bfd
, section_name
);
528 warning (_("Couldn't find %s registers in core file."),
533 size
= bfd_section_size (core_bfd
, section
);
534 contents
= alloca (size
);
535 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
538 warning (_("Couldn't read %s registers from `%s' section in core file."),
543 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
545 const struct regset
*regset
;
547 regset
= gdbarch_regset_from_core_section (core_gdbarch
,
552 warning (_("Couldn't recognize %s registers in core file."),
557 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
561 gdb_assert (core_vec
);
562 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
564 bfd_section_vma (core_bfd
, section
)));
568 /* Get the registers out of a core file. This is the machine-
569 independent part. Fetch_core_registers is the machine-dependent
570 part, typically implemented in the xm-file for each
573 /* We just get all the registers, so we don't use regno. */
576 get_core_registers (struct target_ops
*ops
,
577 struct regcache
*regcache
, int regno
)
579 struct core_regset_section
*sect_list
;
582 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
583 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
585 fprintf_filtered (gdb_stderr
,
586 "Can't fetch registers from this type of core file\n");
590 sect_list
= gdbarch_core_regset_sections (get_regcache_arch (regcache
));
592 while (sect_list
->sect_name
!= NULL
)
594 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
595 get_core_register_section (regcache
, sect_list
->sect_name
,
596 0, sect_list
->human_name
, 1);
597 else if (strcmp (sect_list
->sect_name
, ".reg2") == 0)
598 get_core_register_section (regcache
, sect_list
->sect_name
,
599 2, sect_list
->human_name
, 0);
601 get_core_register_section (regcache
, sect_list
->sect_name
,
602 3, sect_list
->human_name
, 0);
609 get_core_register_section (regcache
,
610 ".reg", 0, "general-purpose", 1);
611 get_core_register_section (regcache
,
612 ".reg2", 2, "floating-point", 0);
615 /* Mark all registers not found in the core as unavailable. */
616 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
617 if (regcache_register_status (regcache
, i
) == REG_UNKNOWN
)
618 regcache_raw_supply (regcache
, i
, NULL
);
622 core_files_info (struct target_ops
*t
)
624 print_section_info (core_data
, core_bfd
);
637 add_to_spuid_list (bfd
*abfd
, asection
*asect
, void *list_p
)
639 struct spuid_list
*list
= list_p
;
640 enum bfd_endian byte_order
641 = bfd_big_endian (abfd
) ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
644 sscanf (bfd_section_name (abfd
, asect
), "SPU/%d/regs%n", &fd
, &pos
);
648 if (list
->pos
>= list
->offset
&& list
->pos
+ 4 <= list
->offset
+ list
->len
)
650 store_unsigned_integer (list
->buf
+ list
->pos
- list
->offset
,
657 /* Read siginfo data from the core, if possible. Returns -1 on
658 failure. Otherwise, returns the number of bytes read. ABFD is the
659 core file's BFD; READBUF, OFFSET, and LEN are all as specified by
660 the to_xfer_partial interface. */
663 get_core_siginfo (bfd
*abfd
, gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
)
667 const char *name
= ".note.linuxcore.siginfo";
669 if (ptid_get_lwp (inferior_ptid
))
670 section_name
= xstrprintf ("%s/%ld", name
,
671 ptid_get_lwp (inferior_ptid
));
673 section_name
= xstrdup (name
);
675 section
= bfd_get_section_by_name (abfd
, section_name
);
676 xfree (section_name
);
680 if (!bfd_get_section_contents (abfd
, section
, readbuf
, offset
, len
))
687 core_xfer_partial (struct target_ops
*ops
, enum target_object object
,
688 const char *annex
, gdb_byte
*readbuf
,
689 const gdb_byte
*writebuf
, ULONGEST offset
,
694 case TARGET_OBJECT_MEMORY
:
695 return section_table_xfer_memory_partial (readbuf
, writebuf
,
698 core_data
->sections_end
,
701 case TARGET_OBJECT_AUXV
:
704 /* When the aux vector is stored in core file, BFD
705 represents this with a fake section called ".auxv". */
707 struct bfd_section
*section
;
710 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
714 size
= bfd_section_size (core_bfd
, section
);
721 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
722 (file_ptr
) offset
, size
))
724 warning (_("Couldn't read NT_AUXV note in core file."));
732 case TARGET_OBJECT_WCOOKIE
:
735 /* When the StackGhost cookie is stored in core file, BFD
736 represents this with a fake section called
739 struct bfd_section
*section
;
742 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
746 size
= bfd_section_size (core_bfd
, section
);
753 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
754 (file_ptr
) offset
, size
))
756 warning (_("Couldn't read StackGhost cookie in core file."));
764 case TARGET_OBJECT_LIBRARIES
:
766 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch
))
771 gdbarch_core_xfer_shared_libraries (core_gdbarch
,
772 readbuf
, offset
, len
);
776 case TARGET_OBJECT_SPU
:
777 if (readbuf
&& annex
)
779 /* When the SPU contexts are stored in a core file, BFD
780 represents this with a fake section called
783 struct bfd_section
*section
;
785 char sectionstr
[100];
787 xsnprintf (sectionstr
, sizeof sectionstr
, "SPU/%s", annex
);
789 section
= bfd_get_section_by_name (core_bfd
, sectionstr
);
793 size
= bfd_section_size (core_bfd
, section
);
800 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
801 (file_ptr
) offset
, size
))
803 warning (_("Couldn't read SPU section in core file."));
811 /* NULL annex requests list of all present spuids. */
812 struct spuid_list list
;
815 list
.offset
= offset
;
819 bfd_map_over_sections (core_bfd
, add_to_spuid_list
, &list
);
824 case TARGET_OBJECT_SIGNAL_INFO
:
826 return get_core_siginfo (core_bfd
, readbuf
, offset
, len
);
830 if (ops
->beneath
!= NULL
)
831 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
,
833 writebuf
, offset
, len
);
839 /* If mourn is being called in all the right places, this could be say
840 `gdb internal error' (since generic_mourn calls
841 breakpoint_init_inferior). */
844 ignore (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
850 /* Okay, let's be honest: threads gleaned from a core file aren't
851 exactly lively, are they? On the other hand, if we don't claim
852 that each & every one is alive, then we don't get any of them
853 to appear in an "info thread" command, which is quite a useful
857 core_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
862 /* Ask the current architecture what it knows about this core file.
863 That will be used, in turn, to pick a better architecture. This
864 wrapper could be avoided if targets got a chance to specialize
867 static const struct target_desc
*
868 core_read_description (struct target_ops
*target
)
870 if (core_gdbarch
&& gdbarch_core_read_description_p (core_gdbarch
))
871 return gdbarch_core_read_description (core_gdbarch
,
878 core_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
881 struct inferior
*inf
;
884 /* The preferred way is to have a gdbarch/OS specific
887 && gdbarch_core_pid_to_str_p (core_gdbarch
))
888 return gdbarch_core_pid_to_str (core_gdbarch
, ptid
);
890 /* Otherwise, if we don't have one, we'll just fallback to
891 "process", with normal_pid_to_str. */
893 /* Try the LWPID field first. */
894 pid
= ptid_get_lwp (ptid
);
896 return normal_pid_to_str (pid_to_ptid (pid
));
898 /* Otherwise, this isn't a "threaded" core -- use the PID field, but
899 only if it isn't a fake PID. */
900 inf
= find_inferior_pid (ptid_get_pid (ptid
));
901 if (inf
!= NULL
&& !inf
->fake_pid_p
)
902 return normal_pid_to_str (ptid
);
904 /* No luck. We simply don't have a valid PID to print. */
905 xsnprintf (buf
, sizeof buf
, "<main task>");
910 core_has_memory (struct target_ops
*ops
)
912 return (core_bfd
!= NULL
);
916 core_has_stack (struct target_ops
*ops
)
918 return (core_bfd
!= NULL
);
922 core_has_registers (struct target_ops
*ops
)
924 return (core_bfd
!= NULL
);
927 /* Implement the to_info_proc method. */
930 core_info_proc (struct target_ops
*ops
, char *args
, enum info_proc_what request
)
932 struct gdbarch
*gdbarch
= get_current_arch ();
934 /* Since this is the core file target, call the 'core_info_proc'
935 method on gdbarch, not 'info_proc'. */
936 if (gdbarch_core_info_proc_p (gdbarch
))
937 gdbarch_core_info_proc (gdbarch
, args
, request
);
940 /* Fill in core_ops with its defined operations and properties. */
945 core_ops
.to_shortname
= "core";
946 core_ops
.to_longname
= "Local core dump file";
948 "Use a core file as a target. Specify the filename of the core file.";
949 core_ops
.to_open
= core_open
;
950 core_ops
.to_close
= core_close
;
951 core_ops
.to_attach
= find_default_attach
;
952 core_ops
.to_detach
= core_detach
;
953 core_ops
.to_fetch_registers
= get_core_registers
;
954 core_ops
.to_xfer_partial
= core_xfer_partial
;
955 core_ops
.to_files_info
= core_files_info
;
956 core_ops
.to_insert_breakpoint
= ignore
;
957 core_ops
.to_remove_breakpoint
= ignore
;
958 core_ops
.to_create_inferior
= find_default_create_inferior
;
959 core_ops
.to_thread_alive
= core_thread_alive
;
960 core_ops
.to_read_description
= core_read_description
;
961 core_ops
.to_pid_to_str
= core_pid_to_str
;
962 core_ops
.to_stratum
= process_stratum
;
963 core_ops
.to_has_memory
= core_has_memory
;
964 core_ops
.to_has_stack
= core_has_stack
;
965 core_ops
.to_has_registers
= core_has_registers
;
966 core_ops
.to_info_proc
= core_info_proc
;
967 core_ops
.to_magic
= OPS_MAGIC
;
970 internal_error (__FILE__
, __LINE__
,
971 _("init_core_ops: core target already exists (\"%s\")."),
972 core_target
->to_longname
);
973 core_target
= &core_ops
;
977 _initialize_corelow (void)
981 add_target_with_completer (&core_ops
, filename_completer
);