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 /* 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 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 gdb
107 startup by the _initialize routine in each core file register reader, to
108 register information about each format the the reader is prepared to
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 CORE_GDBARCH. */
144 if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
147 for (cf = core_file_fns; cf != NULL; cf = cf->next)
149 if (cf->core_sniffer (cf, abfd))
157 warning (_("\"%s\": ambiguous core format, %d handlers match"),
158 bfd_get_filename (abfd), matches);
160 else if (matches == 0)
162 warning (_("\"%s\": no core file handler recognizes format, using default"),
163 bfd_get_filename (abfd));
167 yummy = core_file_fns;
172 /* The default is to reject every core file format we see. Either
173 BFD has to recognize it, or we have to provide a function in the
174 core file handler that recognizes it. */
177 default_check_format (bfd *abfd)
182 /* Attempt to recognize core file formats that BFD rejects. */
185 gdb_check_format (bfd *abfd)
189 for (cf = core_file_fns; cf != NULL; cf = cf->next)
191 if (cf->check_format (abfd))
199 /* Discard all vestiges of any previous core file and mark data and stack
203 core_close (int quitting)
209 int pid = ptid_get_pid (inferior_ptid);
210 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */
211 delete_inferior_silent (pid);
213 /* Clear out solib state while the bfd is still open. See
214 comments in clear_solib in solib.c. */
217 xfree (core_data->sections);
220 core_has_fake_pid = 0;
222 name = bfd_get_filename (core_bfd);
223 if (!bfd_close (core_bfd))
224 warning (_("cannot close \"%s\": %s"),
225 name, bfd_errmsg (bfd_get_error ()));
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_PRSTATUS note in the core, but do find NT_LWPSTATUS
267 core_has_fake_pid = 1;
273 core_has_fake_pid = 1;
278 if (!in_inferior_list (pid))
279 add_inferior_silent (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;
304 int corelow_pid = CORELOW_PID;
306 target_preopen (from_tty);
310 error (_("No core file specified. (Use `detach' to stop debugging a core file.)"));
312 error (_("No core file specified."));
315 filename = tilde_expand (filename);
316 if (!IS_ABSOLUTE_PATH(filename))
318 temp = concat (current_directory, "/", filename, (char *)NULL);
323 old_chain = make_cleanup (xfree, filename);
325 flags = O_BINARY | O_LARGEFILE;
330 scratch_chan = open (filename, flags, 0);
331 if (scratch_chan < 0)
332 perror_with_name (filename);
334 temp_bfd = bfd_fopen (filename, gnutarget,
335 write_files ? FOPEN_RUB : FOPEN_RB,
337 if (temp_bfd == NULL)
338 perror_with_name (filename);
340 if (!bfd_check_format (temp_bfd, bfd_core)
341 && !gdb_check_format (temp_bfd))
343 /* Do it after the err msg */
344 /* FIXME: should be checking for errors from bfd_close (for one thing,
345 on error it does not free all the storage associated with the
347 make_cleanup_bfd_close (temp_bfd);
348 error (_("\"%s\" is not a core dump: %s"),
349 filename, bfd_errmsg (bfd_get_error ()));
352 /* Looks semi-reasonable. Toss the old core file and work on the new. */
354 discard_cleanups (old_chain); /* Don't free filename any more */
355 unpush_target (&core_ops);
357 old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
359 /* FIXME: kettenis/20031023: This is very dangerous. The
360 CORE_GDBARCH that results from this call may very well be
361 different from CURRENT_GDBARCH. However, its methods may only
362 work if it is selected as the current architecture, because they
363 rely on swapped data (see gdbarch.c). We should get rid of that
365 core_gdbarch = gdbarch_from_bfd (core_bfd);
367 /* Find a suitable core file handler to munch on core_bfd */
368 core_vec = sniff_core_bfd (core_bfd);
372 core_data = XZALLOC (struct target_section_table);
374 /* Find the data section */
375 if (build_section_table (core_bfd,
376 &core_data->sections, &core_data->sections_end))
377 error (_("\"%s\": Can't find sections: %s"),
378 bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
380 /* If we have no exec file, try to set the architecture from the
381 core file. We don't do this unconditionally since an exec file
382 typically contains more information that helps us determine the
383 architecture than a core file. */
385 set_gdbarch_from_file (core_bfd);
387 push_target (&core_ops);
388 discard_cleanups (old_chain);
390 /* Do this before acknowledging the inferior, so if
391 post_create_inferior throws (can happen easilly if you're loading
392 a core file with the wrong exec), we aren't left with threads
393 from the previous inferior. */
396 inferior_ptid = null_ptid;
397 core_has_fake_pid = 0;
399 /* Need to flush the register cache (and the frame cache) from a
400 previous debug session. If inferior_ptid ends up the same as the
401 last debug session --- e.g., b foo; run; gcore core1; step; gcore
402 core2; core core1; core core2 --- then there's potential for
403 get_current_regcache to return the cached regcache of the
404 previous session, and the frame cache being stale. */
405 registers_changed ();
407 /* Build up thread list from BFD sections, and possibly set the
408 current thread to the .reg/NN section matching the .reg
410 bfd_map_over_sections (core_bfd, add_to_thread_list,
411 bfd_get_section_by_name (core_bfd, ".reg"));
413 if (ptid_equal (inferior_ptid, null_ptid))
415 /* Either we found no .reg/NN section, and hence we have a
416 non-threaded core (single-threaded, from gdb's perspective),
417 or for some reason add_to_thread_list couldn't determine
418 which was the "main" thread. The latter case shouldn't
419 usually happen, but we're dealing with input here, which can
420 always be broken in different ways. */
421 struct thread_info *thread = first_thread_of_process (-1);
424 add_inferior_silent (CORELOW_PID);
425 inferior_ptid = pid_to_ptid (CORELOW_PID);
426 add_thread_silent (inferior_ptid);
429 switch_to_thread (thread->ptid);
432 post_create_inferior (&core_ops, from_tty);
434 /* Now go through the target stack looking for threads since there
435 may be a thread_stratum target loaded on top of target core by
436 now. The layer above should claim threads found in the BFD
438 target_find_new_threads ();
440 p = bfd_core_file_failing_command (core_bfd);
442 printf_filtered (_("Core was generated by `%s'.\n"), p);
444 siggy = bfd_core_file_failing_signal (core_bfd);
446 /* NOTE: target_signal_from_host() converts a target signal value
447 into gdb's internal signal value. Unfortunately gdb's internal
448 value is called ``target_signal'' and this function got the
449 name ..._from_host(). */
450 printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy,
451 target_signal_to_string (
452 (core_gdbarch != NULL) ?
453 gdbarch_target_signal_from_host (core_gdbarch, siggy)
456 /* Fetch all registers from core file. */
457 target_fetch_registers (get_current_regcache (), -1);
459 /* Now, set up the frame cache, and print the top of stack. */
460 reinit_frame_cache ();
461 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
465 core_detach (struct target_ops *ops, char *args, int from_tty)
468 error (_("Too many arguments"));
470 reinit_frame_cache ();
472 printf_filtered (_("No core file now.\n"));
475 #ifdef DEPRECATED_IBM6000_TARGET
477 /* Resize the core memory's section table, by NUM_ADDED. Returns a
478 pointer into the first new slot. This will not be necessary when
479 the rs6000 target is converted to use the standard solib
482 struct target_section *
483 deprecated_core_resize_section_table (int num_added)
487 old_count = resize_section_table (core_data, num_added);
488 return core_data->sections + old_count;
493 /* Try to retrieve registers from a section in core_bfd, and supply
494 them to core_vec->core_read_registers, as the register set numbered
497 If inferior_ptid's lwp member is zero, do the single-threaded
498 thing: look for a section named NAME. If inferior_ptid's lwp
499 member is non-zero, do the multi-threaded thing: look for a section
500 named "NAME/LWP", where LWP is the shortest ASCII decimal
501 representation of inferior_ptid's lwp member.
503 HUMAN_NAME is a human-readable name for the kind of registers the
504 NAME section contains, for use in error messages.
506 If REQUIRED is non-zero, print an error if the core file doesn't
507 have a section by the appropriate name. Otherwise, just do nothing. */
510 get_core_register_section (struct regcache *regcache,
516 static char *section_name = NULL;
517 struct bfd_section *section;
521 xfree (section_name);
524 && gdbarch_core_reg_section_encodes_pid (core_gdbarch))
527 int pid = ptid_get_pid (inferior_ptid);
529 if (core_has_fake_pid)
532 merged_pid = ptid_get_lwp (inferior_ptid);
533 merged_pid = merged_pid << 16 | pid;
535 section_name = xstrprintf ("%s/%s", name, plongest (merged_pid));
537 else if (ptid_get_lwp (inferior_ptid))
538 section_name = xstrprintf ("%s/%ld", name, ptid_get_lwp (inferior_ptid));
540 section_name = xstrdup (name);
542 section = bfd_get_section_by_name (core_bfd, section_name);
546 warning (_("Couldn't find %s registers in core file."), human_name);
550 size = bfd_section_size (core_bfd, section);
551 contents = alloca (size);
552 if (! bfd_get_section_contents (core_bfd, section, contents,
555 warning (_("Couldn't read %s registers from `%s' section in core file."),
560 if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
562 const struct regset *regset;
564 regset = gdbarch_regset_from_core_section (core_gdbarch, name, size);
568 warning (_("Couldn't recognize %s registers in core file."),
573 regset->supply_regset (regset, regcache, -1, contents, size);
577 gdb_assert (core_vec);
578 core_vec->core_read_registers (regcache, contents, size, which,
580 bfd_section_vma (core_bfd, section)));
584 /* Get the registers out of a core file. This is the machine-
585 independent part. Fetch_core_registers is the machine-dependent
586 part, typically implemented in the xm-file for each architecture. */
588 /* We just get all the registers, so we don't use regno. */
591 get_core_registers (struct target_ops *ops,
592 struct regcache *regcache, int regno)
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 get_core_register_section (regcache,
605 ".reg", 0, "general-purpose", 1);
606 get_core_register_section (regcache,
607 ".reg2", 2, "floating-point", 0);
608 get_core_register_section (regcache,
609 ".reg-xfp", 3, "extended floating-point", 0);
610 get_core_register_section (regcache,
611 ".reg-ppc-vmx", 3, "ppc Altivec", 0);
612 get_core_register_section (regcache,
613 ".reg-ppc-vsx", 4, "POWER7 VSX", 0);
615 /* Supply dummy value for all registers not found in the core. */
616 for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
617 if (!regcache_valid_p (regcache, i))
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,
658 core_xfer_partial (struct target_ops *ops, enum target_object object,
659 const char *annex, gdb_byte *readbuf,
660 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
664 case TARGET_OBJECT_MEMORY:
665 return section_table_xfer_memory_partial (readbuf, writebuf,
668 core_data->sections_end,
671 case TARGET_OBJECT_AUXV:
674 /* When the aux vector is stored in core file, BFD
675 represents this with a fake section called ".auxv". */
677 struct bfd_section *section;
681 section = bfd_get_section_by_name (core_bfd, ".auxv");
685 size = bfd_section_size (core_bfd, section);
692 && !bfd_get_section_contents (core_bfd, section, readbuf,
693 (file_ptr) offset, size))
695 warning (_("Couldn't read NT_AUXV note in core file."));
703 case TARGET_OBJECT_WCOOKIE:
706 /* When the StackGhost cookie is stored in core file, BFD
707 represents this with a fake section called ".wcookie". */
709 struct bfd_section *section;
713 section = bfd_get_section_by_name (core_bfd, ".wcookie");
717 size = bfd_section_size (core_bfd, section);
724 && !bfd_get_section_contents (core_bfd, section, readbuf,
725 (file_ptr) offset, size))
727 warning (_("Couldn't read StackGhost cookie in core file."));
735 case TARGET_OBJECT_LIBRARIES:
737 && gdbarch_core_xfer_shared_libraries_p (core_gdbarch))
742 gdbarch_core_xfer_shared_libraries (core_gdbarch,
743 readbuf, offset, len);
747 case TARGET_OBJECT_SPU:
748 if (readbuf && annex)
750 /* When the SPU contexts are stored in a core file, BFD
751 represents this with a fake section called "SPU/<annex>". */
753 struct bfd_section *section;
757 char sectionstr[100];
758 xsnprintf (sectionstr, sizeof sectionstr, "SPU/%s", annex);
760 section = bfd_get_section_by_name (core_bfd, sectionstr);
764 size = bfd_section_size (core_bfd, section);
771 && !bfd_get_section_contents (core_bfd, section, readbuf,
772 (file_ptr) offset, size))
774 warning (_("Couldn't read SPU section in core file."));
782 /* NULL annex requests list of all present spuids. */
783 struct spuid_list list;
785 list.offset = offset;
789 bfd_map_over_sections (core_bfd, add_to_spuid_list, &list);
795 if (ops->beneath != NULL)
796 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
797 readbuf, writebuf, offset, len);
803 /* If mourn is being called in all the right places, this could be say
804 `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
807 ignore (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
813 /* Okay, let's be honest: threads gleaned from a core file aren't
814 exactly lively, are they? On the other hand, if we don't claim
815 that each & every one is alive, then we don't get any of them
816 to appear in an "info thread" command, which is quite a useful
820 core_thread_alive (struct target_ops *ops, ptid_t ptid)
825 /* Ask the current architecture what it knows about this core file.
826 That will be used, in turn, to pick a better architecture. This
827 wrapper could be avoided if targets got a chance to specialize
830 static const struct target_desc *
831 core_read_description (struct target_ops *target)
833 if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
834 return gdbarch_core_read_description (core_gdbarch, target, core_bfd);
840 core_pid_to_str (struct target_ops *ops, ptid_t ptid)
845 && gdbarch_core_pid_to_str_p (core_gdbarch))
847 char *ret = gdbarch_core_pid_to_str (core_gdbarch, ptid);
852 if (ptid_get_lwp (ptid) == 0)
853 xsnprintf (buf, sizeof buf, "<main task>");
855 xsnprintf (buf, sizeof buf, "Thread %ld", ptid_get_lwp (ptid));
861 core_has_memory (struct target_ops *ops)
863 return (core_bfd != NULL);
867 core_has_stack (struct target_ops *ops)
869 return (core_bfd != NULL);
873 core_has_registers (struct target_ops *ops)
875 return (core_bfd != NULL);
878 /* Fill in core_ops with its defined operations and properties. */
883 core_ops.to_shortname = "core";
884 core_ops.to_longname = "Local core dump file";
886 "Use a core file as a target. Specify the filename of the core file.";
887 core_ops.to_open = core_open;
888 core_ops.to_close = core_close;
889 core_ops.to_attach = find_default_attach;
890 core_ops.to_detach = core_detach;
891 core_ops.to_fetch_registers = get_core_registers;
892 core_ops.to_xfer_partial = core_xfer_partial;
893 core_ops.to_files_info = core_files_info;
894 core_ops.to_insert_breakpoint = ignore;
895 core_ops.to_remove_breakpoint = ignore;
896 core_ops.to_create_inferior = find_default_create_inferior;
897 core_ops.to_thread_alive = core_thread_alive;
898 core_ops.to_read_description = core_read_description;
899 core_ops.to_pid_to_str = core_pid_to_str;
900 core_ops.to_stratum = core_stratum;
901 core_ops.to_has_memory = core_has_memory;
902 core_ops.to_has_stack = core_has_stack;
903 core_ops.to_has_registers = core_has_registers;
904 core_ops.to_magic = OPS_MAGIC;
908 _initialize_corelow (void)
912 add_target (&core_ops);