1 /* Core dump and executable file functions below target vector, for GDB.
3 Copyright (C) 1986-1987, 1989, 1991-2001, 2003-2012 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
23 #include "gdb_string.h"
27 #ifdef HAVE_SYS_FILE_H
28 #include <sys/file.h> /* needed for F_OK and friends */
30 #include "frame.h" /* required by inferior.h */
37 #include "gdbthread.h"
42 #include "readline/readline.h"
43 #include "gdb_assert.h"
44 #include "exceptions.h"
46 #include "filenames.h"
47 #include "progspace.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
61 core 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 /* Per-core data. Currently, only the section table. Note that these
71 target sections are *not* mapped in the current address spaces' set
72 of target sections --- those should come only from pure executable
73 or shared library bfds. The core bfd sections are an
74 implementation detail of the core target, just like ptrace is for
75 unix child targets. */
76 static struct target_section_table
*core_data
;
78 /* True if we needed to fake the pid of the loaded core inferior. */
79 static int core_has_fake_pid
= 0;
81 static void core_files_info (struct target_ops
*);
83 static struct core_fns
*sniff_core_bfd (bfd
*);
85 static int gdb_check_format (bfd
*);
87 static void core_open (char *, int);
89 static void core_detach (struct target_ops
*ops
, char *, int);
91 static void core_close (int);
93 static void core_close_cleanup (void *ignore
);
95 static void add_to_thread_list (bfd
*, asection
*, void *);
97 static void init_core_ops (void);
99 void _initialize_corelow (void);
101 static struct target_ops core_ops
;
103 /* An arbitrary identifier for the core inferior. */
104 #define CORELOW_PID 1
106 /* Link a new core_fns into the global core_file_fns list. Called on
107 gdb startup by the _initialize routine in each core file register
108 reader, to register information about each format the reader is
109 prepared to handle. */
112 deprecated_add_core_fns (struct core_fns
*cf
)
114 cf
->next
= core_file_fns
;
118 /* The default function that core file handlers can use to examine a
119 core file BFD and decide whether or not to accept the job of
120 reading the core file. */
123 default_core_sniffer (struct core_fns
*our_fns
, bfd
*abfd
)
127 result
= (bfd_get_flavour (abfd
) == our_fns
-> core_flavour
);
131 /* Walk through the list of core functions to find a set that can
132 handle the core file open on ABFD. Default to the first one in the
133 list if nothing matches. Returns pointer to set that is
136 static struct core_fns
*
137 sniff_core_bfd (bfd
*abfd
)
140 struct core_fns
*yummy
= NULL
;
143 /* Don't sniff if we have support for register sets in
145 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
148 for (cf
= core_file_fns
; cf
!= NULL
; cf
= cf
->next
)
150 if (cf
->core_sniffer (cf
, abfd
))
158 warning (_("\"%s\": ambiguous core format, %d handlers match"),
159 bfd_get_filename (abfd
), matches
);
161 else if (matches
== 0)
163 warning (_("\"%s\": no core file handler "
164 "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
202 stack spaces as empty. */
205 core_close (int quitting
)
211 int pid
= ptid_get_pid (inferior_ptid
);
212 inferior_ptid
= null_ptid
; /* Avoid confusion from thread
214 exit_inferior_silent (pid
);
216 /* Clear out solib state while the bfd is still open. See
217 comments in clear_solib in solib.c. */
220 xfree (core_data
->sections
);
223 core_has_fake_pid
= 0;
225 name
= bfd_get_filename (core_bfd
);
226 gdb_bfd_close_or_warn (core_bfd
);
235 core_close_cleanup (void *ignore
)
237 core_close (0/*ignored*/);
240 /* Look for sections whose names start with `.reg/' so that we can
241 extract the list of threads in a core file. */
244 add_to_thread_list (bfd
*abfd
, asection
*asect
, void *reg_sect_arg
)
249 asection
*reg_sect
= (asection
*) reg_sect_arg
;
251 if (strncmp (bfd_section_name (abfd
, asect
), ".reg/", 5) != 0)
254 core_tid
= atoi (bfd_section_name (abfd
, asect
) + 5);
256 pid
= bfd_core_file_pid (core_bfd
);
259 core_has_fake_pid
= 1;
265 if (current_inferior ()->pid
== 0)
266 inferior_appeared (current_inferior (), pid
);
268 ptid
= ptid_build (pid
, lwpid
, 0);
272 /* Warning, Will Robinson, looking at BFD private data! */
275 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
276 inferior_ptid
= ptid
; /* Yes, make it current. */
279 /* This routine opens and sets up the core file bfd. */
282 core_open (char *filename
, int from_tty
)
286 struct cleanup
*old_chain
;
291 volatile struct gdb_exception except
;
293 target_preopen (from_tty
);
297 error (_("No core file specified. (Use `detach' "
298 "to stop debugging a core file.)"));
300 error (_("No core file specified."));
303 filename
= tilde_expand (filename
);
304 if (!IS_ABSOLUTE_PATH (filename
))
306 temp
= concat (current_directory
, "/",
307 filename
, (char *) NULL
);
312 old_chain
= make_cleanup (xfree
, filename
);
314 flags
= O_BINARY
| O_LARGEFILE
;
319 scratch_chan
= open (filename
, flags
, 0);
320 if (scratch_chan
< 0)
321 perror_with_name (filename
);
323 temp_bfd
= bfd_fopen (filename
, gnutarget
,
324 write_files
? FOPEN_RUB
: FOPEN_RB
,
326 if (temp_bfd
== NULL
)
327 perror_with_name (filename
);
329 if (!bfd_check_format (temp_bfd
, bfd_core
)
330 && !gdb_check_format (temp_bfd
))
332 /* Do it after the err msg */
333 /* FIXME: should be checking for errors from bfd_close (for one
334 thing, on error it does not free all the storage associated
336 make_cleanup_bfd_close (temp_bfd
);
337 error (_("\"%s\" is not a core dump: %s"),
338 filename
, bfd_errmsg (bfd_get_error ()));
341 /* Looks semi-reasonable. Toss the old core file and work on the
344 discard_cleanups (old_chain
); /* Don't free filename any more */
345 unpush_target (&core_ops
);
347 old_chain
= make_cleanup (core_close_cleanup
, 0 /*ignore*/);
349 /* FIXME: kettenis/20031023: This is very dangerous. The
350 CORE_GDBARCH that results from this call may very well be
351 different from CURRENT_GDBARCH. However, its methods may only
352 work if it is selected as the current architecture, because they
353 rely on swapped data (see gdbarch.c). We should get rid of that
355 core_gdbarch
= gdbarch_from_bfd (core_bfd
);
357 /* Find a suitable core file handler to munch on core_bfd */
358 core_vec
= sniff_core_bfd (core_bfd
);
362 core_data
= XZALLOC (struct target_section_table
);
364 /* Find the data section */
365 if (build_section_table (core_bfd
,
366 &core_data
->sections
,
367 &core_data
->sections_end
))
368 error (_("\"%s\": Can't find sections: %s"),
369 bfd_get_filename (core_bfd
), bfd_errmsg (bfd_get_error ()));
371 /* If we have no exec file, try to set the architecture from the
372 core file. We don't do this unconditionally since an exec file
373 typically contains more information that helps us determine the
374 architecture than a core file. */
376 set_gdbarch_from_file (core_bfd
);
378 push_target (&core_ops
);
379 discard_cleanups (old_chain
);
381 /* Do this before acknowledging the inferior, so if
382 post_create_inferior throws (can happen easilly if you're loading
383 a core file with the wrong exec), we aren't left with threads
384 from the previous inferior. */
387 inferior_ptid
= null_ptid
;
388 core_has_fake_pid
= 0;
390 /* Need to flush the register cache (and the frame cache) from a
391 previous debug session. If inferior_ptid ends up the same as the
392 last debug session --- e.g., b foo; run; gcore core1; step; gcore
393 core2; core core1; core core2 --- then there's potential for
394 get_current_regcache to return the cached regcache of the
395 previous session, and the frame cache being stale. */
396 registers_changed ();
398 /* Build up thread list from BFD sections, and possibly set the
399 current thread to the .reg/NN section matching the .reg
401 bfd_map_over_sections (core_bfd
, add_to_thread_list
,
402 bfd_get_section_by_name (core_bfd
, ".reg"));
404 if (ptid_equal (inferior_ptid
, null_ptid
))
406 /* Either we found no .reg/NN section, and hence we have a
407 non-threaded core (single-threaded, from gdb's perspective),
408 or for some reason add_to_thread_list couldn't determine
409 which was the "main" thread. The latter case shouldn't
410 usually happen, but we're dealing with input here, which can
411 always be broken in different ways. */
412 struct thread_info
*thread
= first_thread_of_process (-1);
416 inferior_appeared (current_inferior (), CORELOW_PID
);
417 inferior_ptid
= pid_to_ptid (CORELOW_PID
);
418 add_thread_silent (inferior_ptid
);
421 switch_to_thread (thread
->ptid
);
424 post_create_inferior (&core_ops
, from_tty
);
426 /* Now go through the target stack looking for threads since there
427 may be a thread_stratum target loaded on top of target core by
428 now. The layer above should claim threads found in the BFD
430 TRY_CATCH (except
, RETURN_MASK_ERROR
)
432 target_find_new_threads ();
435 if (except
.reason
< 0)
436 exception_print (gdb_stderr
, except
);
438 p
= bfd_core_file_failing_command (core_bfd
);
440 printf_filtered (_("Core was generated by `%s'.\n"), p
);
442 siggy
= bfd_core_file_failing_signal (core_bfd
);
445 /* NOTE: target_signal_from_host() converts a target signal
446 value into gdb's internal signal value. Unfortunately gdb's
447 internal value is called ``target_signal'' and this function
448 got the name ..._from_host(). */
449 enum target_signal sig
= (core_gdbarch
!= NULL
450 ? gdbarch_target_signal_from_host (core_gdbarch
,
452 : target_signal_from_host (siggy
));
454 printf_filtered (_("Program terminated with signal %d, %s.\n"),
455 siggy
, target_signal_to_string (sig
));
458 /* Fetch all registers from core file. */
459 target_fetch_registers (get_current_regcache (), -1);
461 /* Now, set up the frame cache, and print the top of stack. */
462 reinit_frame_cache ();
463 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
467 core_detach (struct target_ops
*ops
, char *args
, int from_tty
)
470 error (_("Too many arguments"));
472 reinit_frame_cache ();
474 printf_filtered (_("No core file now.\n"));
477 #ifdef DEPRECATED_IBM6000_TARGET
479 /* Resize the core memory's section table, by NUM_ADDED. Returns a
480 pointer into the first new slot. This will not be necessary when
481 the rs6000 target is converted to use the standard solib
484 struct target_section
*
485 deprecated_core_resize_section_table (int num_added
)
489 old_count
= resize_section_table (core_data
, num_added
);
490 return core_data
->sections
+ old_count
;
495 /* Try to retrieve registers from a section in core_bfd, and supply
496 them to core_vec->core_read_registers, as the register set numbered
499 If inferior_ptid's lwp member is zero, do the single-threaded
500 thing: look for a section named NAME. If inferior_ptid's lwp
501 member is non-zero, do the multi-threaded thing: look for a section
502 named "NAME/LWP", where LWP is the shortest ASCII decimal
503 representation of inferior_ptid's lwp member.
505 HUMAN_NAME is a human-readable name for the kind of registers the
506 NAME section contains, for use in error messages.
508 If REQUIRED is non-zero, print an error if the core file doesn't
509 have a section by the appropriate name. Otherwise, just do
513 get_core_register_section (struct regcache
*regcache
,
516 const char *human_name
,
519 static char *section_name
= NULL
;
520 struct bfd_section
*section
;
524 xfree (section_name
);
526 if (ptid_get_lwp (inferior_ptid
))
527 section_name
= xstrprintf ("%s/%ld", name
,
528 ptid_get_lwp (inferior_ptid
));
530 section_name
= xstrdup (name
);
532 section
= bfd_get_section_by_name (core_bfd
, section_name
);
536 warning (_("Couldn't find %s registers in core file."),
541 size
= bfd_section_size (core_bfd
, section
);
542 contents
= alloca (size
);
543 if (! bfd_get_section_contents (core_bfd
, section
, contents
,
546 warning (_("Couldn't read %s registers from `%s' section in core file."),
551 if (core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
553 const struct regset
*regset
;
555 regset
= gdbarch_regset_from_core_section (core_gdbarch
,
560 warning (_("Couldn't recognize %s registers in core file."),
565 regset
->supply_regset (regset
, regcache
, -1, contents
, size
);
569 gdb_assert (core_vec
);
570 core_vec
->core_read_registers (regcache
, contents
, size
, which
,
572 bfd_section_vma (core_bfd
, section
)));
576 /* Get the registers out of a core file. This is the machine-
577 independent part. Fetch_core_registers is the machine-dependent
578 part, typically implemented in the xm-file for each
581 /* We just get all the registers, so we don't use regno. */
584 get_core_registers (struct target_ops
*ops
,
585 struct regcache
*regcache
, int regno
)
587 struct core_regset_section
*sect_list
;
590 if (!(core_gdbarch
&& gdbarch_regset_from_core_section_p (core_gdbarch
))
591 && (core_vec
== NULL
|| core_vec
->core_read_registers
== NULL
))
593 fprintf_filtered (gdb_stderr
,
594 "Can't fetch registers from this type of core file\n");
598 sect_list
= gdbarch_core_regset_sections (get_regcache_arch (regcache
));
600 while (sect_list
->sect_name
!= NULL
)
602 if (strcmp (sect_list
->sect_name
, ".reg") == 0)
603 get_core_register_section (regcache
, sect_list
->sect_name
,
604 0, sect_list
->human_name
, 1);
605 else if (strcmp (sect_list
->sect_name
, ".reg2") == 0)
606 get_core_register_section (regcache
, sect_list
->sect_name
,
607 2, sect_list
->human_name
, 0);
609 get_core_register_section (regcache
, sect_list
->sect_name
,
610 3, sect_list
->human_name
, 0);
617 get_core_register_section (regcache
,
618 ".reg", 0, "general-purpose", 1);
619 get_core_register_section (regcache
,
620 ".reg2", 2, "floating-point", 0);
623 /* Mark all registers not found in the core as unavailable. */
624 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
625 if (regcache_register_status (regcache
, i
) == REG_UNKNOWN
)
626 regcache_raw_supply (regcache
, i
, NULL
);
630 core_files_info (struct target_ops
*t
)
632 print_section_info (core_data
, core_bfd
);
645 add_to_spuid_list (bfd
*abfd
, asection
*asect
, void *list_p
)
647 struct spuid_list
*list
= list_p
;
648 enum bfd_endian byte_order
649 = bfd_big_endian (abfd
) ? BFD_ENDIAN_BIG
: BFD_ENDIAN_LITTLE
;
652 sscanf (bfd_section_name (abfd
, asect
), "SPU/%d/regs%n", &fd
, &pos
);
656 if (list
->pos
>= list
->offset
&& list
->pos
+ 4 <= list
->offset
+ list
->len
)
658 store_unsigned_integer (list
->buf
+ list
->pos
- list
->offset
,
666 core_xfer_partial (struct target_ops
*ops
, enum target_object object
,
667 const char *annex
, gdb_byte
*readbuf
,
668 const gdb_byte
*writebuf
, ULONGEST offset
,
673 case TARGET_OBJECT_MEMORY
:
674 return section_table_xfer_memory_partial (readbuf
, writebuf
,
677 core_data
->sections_end
,
680 case TARGET_OBJECT_AUXV
:
683 /* When the aux vector is stored in core file, BFD
684 represents this with a fake section called ".auxv". */
686 struct bfd_section
*section
;
689 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
693 size
= bfd_section_size (core_bfd
, section
);
700 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
701 (file_ptr
) offset
, size
))
703 warning (_("Couldn't read NT_AUXV note in core file."));
711 case TARGET_OBJECT_WCOOKIE
:
714 /* When the StackGhost cookie is stored in core file, BFD
715 represents this with a fake section called
718 struct bfd_section
*section
;
721 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
725 size
= bfd_section_size (core_bfd
, section
);
732 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
733 (file_ptr
) offset
, size
))
735 warning (_("Couldn't read StackGhost cookie in core file."));
743 case TARGET_OBJECT_LIBRARIES
:
745 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch
))
750 gdbarch_core_xfer_shared_libraries (core_gdbarch
,
751 readbuf
, offset
, len
);
755 case TARGET_OBJECT_SPU
:
756 if (readbuf
&& annex
)
758 /* When the SPU contexts are stored in a core file, BFD
759 represents this with a fake section called
762 struct bfd_section
*section
;
764 char sectionstr
[100];
766 xsnprintf (sectionstr
, sizeof sectionstr
, "SPU/%s", annex
);
768 section
= bfd_get_section_by_name (core_bfd
, sectionstr
);
772 size
= bfd_section_size (core_bfd
, section
);
779 && !bfd_get_section_contents (core_bfd
, section
, readbuf
,
780 (file_ptr
) offset
, size
))
782 warning (_("Couldn't read SPU section in core file."));
790 /* NULL annex requests list of all present spuids. */
791 struct spuid_list list
;
794 list
.offset
= offset
;
798 bfd_map_over_sections (core_bfd
, add_to_spuid_list
, &list
);
804 if (ops
->beneath
!= NULL
)
805 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
,
807 writebuf
, offset
, len
);
813 /* If mourn is being called in all the right places, this could be say
814 `gdb internal error' (since generic_mourn calls
815 breakpoint_init_inferior). */
818 ignore (struct gdbarch
*gdbarch
, struct bp_target_info
*bp_tgt
)
824 /* Okay, let's be honest: threads gleaned from a core file aren't
825 exactly lively, are they? On the other hand, if we don't claim
826 that each & every one is alive, then we don't get any of them
827 to appear in an "info thread" command, which is quite a useful
831 core_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
836 /* Ask the current architecture what it knows about this core file.
837 That will be used, in turn, to pick a better architecture. This
838 wrapper could be avoided if targets got a chance to specialize
841 static const struct target_desc
*
842 core_read_description (struct target_ops
*target
)
844 if (core_gdbarch
&& gdbarch_core_read_description_p (core_gdbarch
))
845 return gdbarch_core_read_description (core_gdbarch
,
852 core_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
857 /* The preferred way is to have a gdbarch/OS specific
860 && gdbarch_core_pid_to_str_p (core_gdbarch
))
861 return gdbarch_core_pid_to_str (core_gdbarch
, ptid
);
863 /* Otherwise, if we don't have one, we'll just fallback to
864 "process", with normal_pid_to_str. */
866 /* Try the LWPID field first. */
867 pid
= ptid_get_lwp (ptid
);
869 return normal_pid_to_str (pid_to_ptid (pid
));
871 /* Otherwise, this isn't a "threaded" core -- use the PID field, but
872 only if it isn't a fake PID. */
873 if (!core_has_fake_pid
)
874 return normal_pid_to_str (ptid
);
876 /* No luck. We simply don't have a valid PID to print. */
877 xsnprintf (buf
, sizeof buf
, "<main task>");
882 core_has_memory (struct target_ops
*ops
)
884 return (core_bfd
!= NULL
);
888 core_has_stack (struct target_ops
*ops
)
890 return (core_bfd
!= NULL
);
894 core_has_registers (struct target_ops
*ops
)
896 return (core_bfd
!= NULL
);
899 /* Fill in core_ops with its defined operations and properties. */
904 core_ops
.to_shortname
= "core";
905 core_ops
.to_longname
= "Local core dump file";
907 "Use a core file as a target. Specify the filename of the core file.";
908 core_ops
.to_open
= core_open
;
909 core_ops
.to_close
= core_close
;
910 core_ops
.to_attach
= find_default_attach
;
911 core_ops
.to_detach
= core_detach
;
912 core_ops
.to_fetch_registers
= get_core_registers
;
913 core_ops
.to_xfer_partial
= core_xfer_partial
;
914 core_ops
.to_files_info
= core_files_info
;
915 core_ops
.to_insert_breakpoint
= ignore
;
916 core_ops
.to_remove_breakpoint
= ignore
;
917 core_ops
.to_create_inferior
= find_default_create_inferior
;
918 core_ops
.to_thread_alive
= core_thread_alive
;
919 core_ops
.to_read_description
= core_read_description
;
920 core_ops
.to_pid_to_str
= core_pid_to_str
;
921 core_ops
.to_stratum
= process_stratum
;
922 core_ops
.to_has_memory
= core_has_memory
;
923 core_ops
.to_has_stack
= core_has_stack
;
924 core_ops
.to_has_registers
= core_has_registers
;
925 core_ops
.to_magic
= OPS_MAGIC
;
928 internal_error (__FILE__
, __LINE__
,
929 _("init_core_ops: core target already exists (\"%s\")."),
930 core_target
->to_longname
);
931 core_target
= &core_ops
;
935 _initialize_corelow (void)
939 add_target (&core_ops
);