1 /* Core dump and executable file functions below target vector, for GDB.
3 Copyright (C) 1986-2022 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"
24 #include "frame.h" /* required by inferior.h */
31 #include "process-stratum-target.h"
33 #include "gdbthread.h"
38 #include "readline/tilde.h"
41 #include "filenames.h"
42 #include "progspace.h"
45 #include "completer.h"
46 #include "gdbsupport/filestuff.h"
48 #include "gdbsupport/pathstuff.h"
49 #include <unordered_map>
50 #include <unordered_set>
52 #include "xml-tdesc.h"
58 /* The core file target. */
60 static const target_info core_target_info
= {
62 N_("Local core dump file"),
63 N_("Use a core file as a target.\n\
64 Specify the filename of the core file.")
67 class core_target final
: public process_stratum_target
72 const target_info
&info () const override
73 { return core_target_info
; }
75 void close () override
;
76 void detach (inferior
*, int) override
;
77 void fetch_registers (struct regcache
*, int) override
;
79 enum target_xfer_status
xfer_partial (enum target_object object
,
82 const gdb_byte
*writebuf
,
83 ULONGEST offset
, ULONGEST len
,
84 ULONGEST
*xfered_len
) override
;
85 void files_info () override
;
87 bool thread_alive (ptid_t ptid
) override
;
88 const struct target_desc
*read_description () override
;
90 std::string
pid_to_str (ptid_t
) override
;
92 const char *thread_name (struct thread_info
*) override
;
94 bool has_all_memory () override
{ return true; }
95 bool has_memory () override
;
96 bool has_stack () override
;
97 bool has_registers () override
;
98 bool has_execution (inferior
*inf
) override
{ return false; }
100 bool info_proc (const char *, enum info_proc_what
) override
;
104 /* Getter, see variable definition. */
105 struct gdbarch
*core_gdbarch ()
107 return m_core_gdbarch
;
110 /* See definition. */
111 void get_core_register_section (struct regcache
*regcache
,
112 const struct regset
*regset
,
114 int section_min_size
,
115 const char *human_name
,
118 /* See definition. */
119 void info_proc_mappings (struct gdbarch
*gdbarch
);
121 private: /* per-core data */
123 /* The core's section table. Note that these target sections are
124 *not* mapped in the current address spaces' set of target
125 sections --- those should come only from pure executable or
126 shared library bfds. The core bfd sections are an implementation
127 detail of the core target, just like ptrace is for unix child
129 target_section_table m_core_section_table
;
131 /* File-backed address space mappings: some core files include
132 information about memory mapped files. */
133 target_section_table m_core_file_mappings
;
135 /* Unavailable mappings. These correspond to pathnames which either
136 weren't found or could not be opened. Knowing these addresses can
138 std::vector
<mem_range
> m_core_unavailable_mappings
;
140 /* Build m_core_file_mappings. Called from the constructor. */
141 void build_file_mappings ();
143 /* Helper method for xfer_partial. */
144 enum target_xfer_status
xfer_memory_via_mappings (gdb_byte
*readbuf
,
145 const gdb_byte
*writebuf
,
148 ULONGEST
*xfered_len
);
150 /* FIXME: kettenis/20031023: Eventually this field should
152 struct gdbarch
*m_core_gdbarch
= NULL
;
155 core_target::core_target ()
157 /* Find a first arch based on the BFD. We need the initial gdbarch so
158 we can setup the hooks to find a target description. */
159 m_core_gdbarch
= gdbarch_from_bfd (core_bfd
);
161 /* If the arch is able to read a target description from the core, it
162 could yield a more specific gdbarch. */
163 const struct target_desc
*tdesc
= read_description ();
165 if (tdesc
!= nullptr)
167 struct gdbarch_info info
;
168 info
.abfd
= core_bfd
;
169 info
.target_desc
= tdesc
;
170 m_core_gdbarch
= gdbarch_find_by_info (info
);
174 || !gdbarch_iterate_over_regset_sections_p (m_core_gdbarch
))
175 error (_("\"%s\": Core file format not supported"),
176 bfd_get_filename (core_bfd
));
178 /* Find the data section */
179 m_core_section_table
= build_section_table (core_bfd
);
181 build_file_mappings ();
184 /* Construct the target_section_table for file-backed mappings if
187 For each unique path in the note, we'll open a BFD with a bfd
188 target of "binary". This is an unstructured bfd target upon which
189 we'll impose a structure from the mappings in the architecture-specific
190 mappings note. A BFD section is allocated and initialized for each
193 We take care to not share already open bfds with other parts of
194 GDB; in particular, we don't want to add new sections to existing
195 BFDs. We do, however, ensure that the BFDs that we allocate here
196 will go away (be deallocated) when the core target is detached. */
199 core_target::build_file_mappings ()
201 std::unordered_map
<std::string
, struct bfd
*> bfd_map
;
202 std::unordered_set
<std::string
> unavailable_paths
;
204 /* See linux_read_core_file_mappings() in linux-tdep.c for an example
205 read_core_file_mappings method. */
206 gdbarch_read_core_file_mappings (m_core_gdbarch
, core_bfd
,
208 /* After determining the number of mappings, read_core_file_mappings
209 will invoke this lambda. */
214 /* read_core_file_mappings will invoke this lambda for each mapping
216 [&] (int num
, ULONGEST start
, ULONGEST end
, ULONGEST file_ofs
,
217 const char *filename
, const bfd_build_id
*build_id
)
219 /* Architecture-specific read_core_mapping methods are expected to
220 weed out non-file-backed mappings. */
221 gdb_assert (filename
!= nullptr);
223 struct bfd
*bfd
= bfd_map
[filename
];
226 /* Use exec_file_find() to do sysroot expansion. It'll
227 also strip the potential sysroot "target:" prefix. If
228 there is no sysroot, an equivalent (possibly more
229 canonical) pathname will be provided. */
230 gdb::unique_xmalloc_ptr
<char> expanded_fname
231 = exec_file_find (filename
, NULL
);
232 if (expanded_fname
== nullptr)
234 m_core_unavailable_mappings
.emplace_back (start
, end
- start
);
235 /* Print just one warning per path. */
236 if (unavailable_paths
.insert (filename
).second
)
237 warning (_("Can't open file %s during file-backed mapping "
243 bfd
= bfd_map
[filename
] = bfd_openr (expanded_fname
.get (),
246 if (bfd
== nullptr || !bfd_check_format (bfd
, bfd_object
))
248 m_core_unavailable_mappings
.emplace_back (start
, end
- start
);
249 /* If we get here, there's a good chance that it's due to
250 an internal error. We issue a warning instead of an
251 internal error because of the possibility that the
252 file was removed in between checking for its
253 existence during the expansion in exec_file_find()
254 and the calls to bfd_openr() / bfd_check_format().
255 Output both the path from the core file note along
256 with its expansion to make debugging this problem
258 warning (_("Can't open file %s which was expanded to %s "
259 "during file-backed mapping note processing"),
260 filename
, expanded_fname
.get ());
265 /* Ensure that the bfd will be closed when core_bfd is closed.
266 This can be checked before/after a core file detach via
267 "maint info bfds". */
268 gdb_bfd_record_inclusion (core_bfd
, bfd
);
271 /* Make new BFD section. All sections have the same name,
272 which is permitted by bfd_make_section_anyway(). */
273 asection
*sec
= bfd_make_section_anyway (bfd
, "load");
275 error (_("Can't make section"));
276 sec
->filepos
= file_ofs
;
277 bfd_set_section_flags (sec
, SEC_READONLY
| SEC_HAS_CONTENTS
);
278 bfd_set_section_size (sec
, end
- start
);
279 bfd_set_section_vma (sec
, start
);
280 bfd_set_section_lma (sec
, start
);
281 bfd_set_section_alignment (sec
, 2);
283 /* Set target_section fields. */
284 m_core_file_mappings
.emplace_back (start
, end
, sec
);
287 normalize_mem_ranges (&m_core_unavailable_mappings
);
290 /* An arbitrary identifier for the core inferior. */
291 #define CORELOW_PID 1
293 /* Close the core target. */
296 core_target::close ()
300 switch_to_no_thread (); /* Avoid confusion from thread
302 exit_inferior_silent (current_inferior ());
304 /* Clear out solib state while the bfd is still open. See
305 comments in clear_solib in solib.c. */
308 current_program_space
->cbfd
.reset (nullptr);
311 /* Core targets are heap-allocated (see core_target_open), so here
312 we delete ourselves. */
316 /* Look for sections whose names start with `.reg/' so that we can
317 extract the list of threads in a core file. */
320 add_to_thread_list (asection
*asect
, asection
*reg_sect
)
324 bool fake_pid_p
= false;
325 struct inferior
*inf
;
327 if (!startswith (bfd_section_name (asect
), ".reg/"))
330 core_tid
= atoi (bfd_section_name (asect
) + 5);
332 pid
= bfd_core_file_pid (core_bfd
);
341 inf
= current_inferior ();
344 inferior_appeared (inf
, pid
);
345 inf
->fake_pid_p
= fake_pid_p
;
348 ptid_t
ptid (pid
, lwpid
);
350 thread_info
*thr
= add_thread (inf
->process_target (), ptid
);
352 /* Warning, Will Robinson, looking at BFD private data! */
355 && asect
->filepos
== reg_sect
->filepos
) /* Did we find .reg? */
356 switch_to_thread (thr
); /* Yes, make it current. */
359 /* Issue a message saying we have no core to debug, if FROM_TTY. */
362 maybe_say_no_core_file_now (int from_tty
)
365 printf_filtered (_("No core file now.\n"));
368 /* Backward compatibility with old way of specifying core files. */
371 core_file_command (const char *filename
, int from_tty
)
373 dont_repeat (); /* Either way, seems bogus. */
375 if (filename
== NULL
)
377 if (core_bfd
!= NULL
)
379 target_detach (current_inferior (), from_tty
);
380 gdb_assert (core_bfd
== NULL
);
383 maybe_say_no_core_file_now (from_tty
);
386 core_target_open (filename
, from_tty
);
389 /* Locate (and load) an executable file (and symbols) given the core file
393 locate_exec_from_corefile_build_id (bfd
*abfd
, int from_tty
)
395 const bfd_build_id
*build_id
= build_id_bfd_get (abfd
);
396 if (build_id
== nullptr)
399 gdb_bfd_ref_ptr execbfd
400 = build_id_to_exec_bfd (build_id
->size
, build_id
->data
);
402 if (execbfd
!= nullptr)
404 exec_file_attach (bfd_get_filename (execbfd
.get ()), from_tty
);
405 symbol_file_add_main (bfd_get_filename (execbfd
.get ()),
406 symfile_add_flag (from_tty
? SYMFILE_VERBOSE
: 0));
413 core_target_open (const char *arg
, int from_tty
)
420 target_preopen (from_tty
);
424 error (_("No core file specified. (Use `detach' "
425 "to stop debugging a core file.)"));
427 error (_("No core file specified."));
430 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (arg
));
431 if (strlen (filename
.get ()) != 0
432 && !IS_ABSOLUTE_PATH (filename
.get ()))
433 filename
= gdb_abspath (filename
.get ());
435 flags
= O_BINARY
| O_LARGEFILE
;
440 scratch_chan
= gdb_open_cloexec (filename
.get (), flags
, 0).release ();
441 if (scratch_chan
< 0)
442 perror_with_name (filename
.get ());
444 gdb_bfd_ref_ptr
temp_bfd (gdb_bfd_fopen (filename
.get (), gnutarget
,
445 write_files
? FOPEN_RUB
: FOPEN_RB
,
447 if (temp_bfd
== NULL
)
448 perror_with_name (filename
.get ());
450 if (!bfd_check_format (temp_bfd
.get (), bfd_core
))
452 /* Do it after the err msg */
453 /* FIXME: should be checking for errors from bfd_close (for one
454 thing, on error it does not free all the storage associated
456 error (_("\"%s\" is not a core dump: %s"),
457 filename
.get (), bfd_errmsg (bfd_get_error ()));
460 current_program_space
->cbfd
= std::move (temp_bfd
);
462 core_target
*target
= new core_target ();
464 /* Own the target until it is successfully pushed. */
465 target_ops_up
target_holder (target
);
469 /* If we have no exec file, try to set the architecture from the
470 core file. We don't do this unconditionally since an exec file
471 typically contains more information that helps us determine the
472 architecture than a core file. */
473 if (!current_program_space
->exec_bfd ())
474 set_gdbarch_from_file (core_bfd
);
476 current_inferior ()->push_target (std::move (target_holder
));
478 switch_to_no_thread ();
480 /* Need to flush the register cache (and the frame cache) from a
481 previous debug session. If inferior_ptid ends up the same as the
482 last debug session --- e.g., b foo; run; gcore core1; step; gcore
483 core2; core core1; core core2 --- then there's potential for
484 get_current_regcache to return the cached regcache of the
485 previous session, and the frame cache being stale. */
486 registers_changed ();
488 /* Build up thread list from BFD sections, and possibly set the
489 current thread to the .reg/NN section matching the .reg
491 asection
*reg_sect
= bfd_get_section_by_name (core_bfd
, ".reg");
492 for (asection
*sect
: gdb_bfd_sections (core_bfd
))
493 add_to_thread_list (sect
, reg_sect
);
495 if (inferior_ptid
== null_ptid
)
497 /* Either we found no .reg/NN section, and hence we have a
498 non-threaded core (single-threaded, from gdb's perspective),
499 or for some reason add_to_thread_list couldn't determine
500 which was the "main" thread. The latter case shouldn't
501 usually happen, but we're dealing with input here, which can
502 always be broken in different ways. */
503 thread_info
*thread
= first_thread_of_inferior (current_inferior ());
507 inferior_appeared (current_inferior (), CORELOW_PID
);
508 thread
= add_thread_silent (target
, ptid_t (CORELOW_PID
));
511 switch_to_thread (thread
);
514 if (current_program_space
->exec_bfd () == nullptr)
515 locate_exec_from_corefile_build_id (core_bfd
, from_tty
);
517 post_create_inferior (from_tty
);
519 /* Now go through the target stack looking for threads since there
520 may be a thread_stratum target loaded on top of target core by
521 now. The layer above should claim threads found in the BFD
525 target_update_thread_list ();
528 catch (const gdb_exception_error
&except
)
530 exception_print (gdb_stderr
, except
);
533 p
= bfd_core_file_failing_command (core_bfd
);
535 printf_filtered (_("Core was generated by `%s'.\n"), p
);
537 /* Clearing any previous state of convenience variables. */
538 clear_exit_convenience_vars ();
540 siggy
= bfd_core_file_failing_signal (core_bfd
);
543 gdbarch
*core_gdbarch
= target
->core_gdbarch ();
545 /* If we don't have a CORE_GDBARCH to work with, assume a native
546 core (map gdb_signal from host signals). If we do have
547 CORE_GDBARCH to work with, but no gdb_signal_from_target
548 implementation for that gdbarch, as a fallback measure,
549 assume the host signal mapping. It'll be correct for native
550 cores, but most likely incorrect for cross-cores. */
551 enum gdb_signal sig
= (core_gdbarch
!= NULL
552 && gdbarch_gdb_signal_from_target_p (core_gdbarch
)
553 ? gdbarch_gdb_signal_from_target (core_gdbarch
,
555 : gdb_signal_from_host (siggy
));
557 printf_filtered (_("Program terminated with signal %s, %s"),
558 gdb_signal_to_name (sig
), gdb_signal_to_string (sig
));
559 if (gdbarch_report_signal_info_p (core_gdbarch
))
560 gdbarch_report_signal_info (core_gdbarch
, current_uiout
, sig
);
561 printf_filtered (_(".\n"));
563 /* Set the value of the internal variable $_exitsignal,
564 which holds the signal uncaught by the inferior. */
565 set_internalvar_integer (lookup_internalvar ("_exitsignal"),
569 /* Fetch all registers from core file. */
570 target_fetch_registers (get_current_regcache (), -1);
572 /* Now, set up the frame cache, and print the top of stack. */
573 reinit_frame_cache ();
574 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
576 /* Current thread should be NUM 1 but the user does not know that.
577 If a program is single threaded gdb in general does not mention
578 anything about threads. That is why the test is >= 2. */
579 if (thread_count (target
) >= 2)
583 thread_command (NULL
, from_tty
);
585 catch (const gdb_exception_error
&except
)
587 exception_print (gdb_stderr
, except
);
593 core_target::detach (inferior
*inf
, int from_tty
)
595 /* Note that 'this' is dangling after this call. unpush_target
596 closes the target, and our close implementation deletes
598 inf
->unpush_target (this);
600 /* Clear the register cache and the frame cache. */
601 registers_changed ();
602 reinit_frame_cache ();
603 maybe_say_no_core_file_now (from_tty
);
606 /* Try to retrieve registers from a section in core_bfd, and supply
609 If ptid's lwp member is zero, do the single-threaded
610 thing: look for a section named NAME. If ptid's lwp
611 member is non-zero, do the multi-threaded thing: look for a section
612 named "NAME/LWP", where LWP is the shortest ASCII decimal
613 representation of ptid's lwp member.
615 HUMAN_NAME is a human-readable name for the kind of registers the
616 NAME section contains, for use in error messages.
618 If REQUIRED is true, print an error if the core file doesn't have a
619 section by the appropriate name. Otherwise, just do nothing. */
622 core_target::get_core_register_section (struct regcache
*regcache
,
623 const struct regset
*regset
,
625 int section_min_size
,
626 const char *human_name
,
629 gdb_assert (regset
!= nullptr);
631 struct bfd_section
*section
;
633 bool variable_size_section
= (regset
->flags
& REGSET_VARIABLE_SIZE
);
635 thread_section_name
section_name (name
, regcache
->ptid ());
637 section
= bfd_get_section_by_name (core_bfd
, section_name
.c_str ());
641 warning (_("Couldn't find %s registers in core file."),
646 size
= bfd_section_size (section
);
647 if (size
< section_min_size
)
649 warning (_("Section `%s' in core file too small."),
650 section_name
.c_str ());
653 if (size
!= section_min_size
&& !variable_size_section
)
655 warning (_("Unexpected size of section `%s' in core file."),
656 section_name
.c_str ());
659 gdb::byte_vector
contents (size
);
660 if (!bfd_get_section_contents (core_bfd
, section
, contents
.data (),
663 warning (_("Couldn't read %s registers from `%s' section in core file."),
664 human_name
, section_name
.c_str ());
668 regset
->supply_regset (regset
, regcache
, -1, contents
.data (), size
);
671 /* Data passed to gdbarch_iterate_over_regset_sections's callback. */
672 struct get_core_registers_cb_data
675 struct regcache
*regcache
;
678 /* Callback for get_core_registers that handles a single core file
679 register note section. */
682 get_core_registers_cb (const char *sect_name
, int supply_size
, int collect_size
,
683 const struct regset
*regset
,
684 const char *human_name
, void *cb_data
)
686 gdb_assert (regset
!= nullptr);
688 auto *data
= (get_core_registers_cb_data
*) cb_data
;
689 bool required
= false;
690 bool variable_size_section
= (regset
->flags
& REGSET_VARIABLE_SIZE
);
692 if (!variable_size_section
)
693 gdb_assert (supply_size
== collect_size
);
695 if (strcmp (sect_name
, ".reg") == 0)
698 if (human_name
== NULL
)
699 human_name
= "general-purpose";
701 else if (strcmp (sect_name
, ".reg2") == 0)
703 if (human_name
== NULL
)
704 human_name
= "floating-point";
707 data
->target
->get_core_register_section (data
->regcache
, regset
, sect_name
,
708 supply_size
, human_name
, required
);
711 /* Get the registers out of a core file. This is the machine-
712 independent part. Fetch_core_registers is the machine-dependent
713 part, typically implemented in the xm-file for each
716 /* We just get all the registers, so we don't use regno. */
719 core_target::fetch_registers (struct regcache
*regcache
, int regno
)
721 if (!(m_core_gdbarch
!= nullptr
722 && gdbarch_iterate_over_regset_sections_p (m_core_gdbarch
)))
724 fprintf_filtered (gdb_stderr
,
725 "Can't fetch registers from this type of core file\n");
729 struct gdbarch
*gdbarch
= regcache
->arch ();
730 get_core_registers_cb_data data
= { this, regcache
};
731 gdbarch_iterate_over_regset_sections (gdbarch
,
732 get_core_registers_cb
,
733 (void *) &data
, NULL
);
735 /* Mark all registers not found in the core as unavailable. */
736 for (int i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
737 if (regcache
->get_register_status (i
) == REG_UNKNOWN
)
738 regcache
->raw_supply (i
, NULL
);
742 core_target::files_info ()
744 print_section_info (&m_core_section_table
, core_bfd
);
747 /* Helper method for core_target::xfer_partial. */
749 enum target_xfer_status
750 core_target::xfer_memory_via_mappings (gdb_byte
*readbuf
,
751 const gdb_byte
*writebuf
,
752 ULONGEST offset
, ULONGEST len
,
753 ULONGEST
*xfered_len
)
755 enum target_xfer_status xfer_status
;
757 xfer_status
= (section_table_xfer_memory_partial
759 offset
, len
, xfered_len
,
760 m_core_file_mappings
));
762 if (xfer_status
== TARGET_XFER_OK
|| m_core_unavailable_mappings
.empty ())
765 /* There are instances - e.g. when debugging within a docker
766 container using the AUFS storage driver - where the pathnames
767 obtained from the note section are incorrect. Despite the path
768 being wrong, just knowing the start and end addresses of the
769 mappings is still useful; we can attempt an access of the file
770 stratum constrained to the address ranges corresponding to the
771 unavailable mappings. */
773 ULONGEST memaddr
= offset
;
774 ULONGEST memend
= offset
+ len
;
776 for (const auto &mr
: m_core_unavailable_mappings
)
778 if (address_in_mem_range (memaddr
, &mr
))
780 if (!address_in_mem_range (memend
, &mr
))
781 len
= mr
.start
+ mr
.length
- memaddr
;
783 xfer_status
= this->beneath ()->xfer_partial (TARGET_OBJECT_MEMORY
,
797 enum target_xfer_status
798 core_target::xfer_partial (enum target_object object
, const char *annex
,
799 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
800 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
804 case TARGET_OBJECT_MEMORY
:
806 enum target_xfer_status xfer_status
;
808 /* Try accessing memory contents from core file data,
809 restricting consideration to those sections for which
810 the BFD section flag SEC_HAS_CONTENTS is set. */
811 auto has_contents_cb
= [] (const struct target_section
*s
)
813 return ((s
->the_bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0);
815 xfer_status
= section_table_xfer_memory_partial
817 offset
, len
, xfered_len
,
818 m_core_section_table
,
820 if (xfer_status
== TARGET_XFER_OK
)
821 return TARGET_XFER_OK
;
823 /* Check file backed mappings. If they're available, use
824 core file provided mappings (e.g. from .note.linuxcore.file
825 or the like) as this should provide a more accurate
826 result. If not, check the stratum beneath us, which should
829 We also check unavailable mappings due to Docker/AUFS driver
831 if (!m_core_file_mappings
.empty ()
832 || !m_core_unavailable_mappings
.empty ())
834 xfer_status
= xfer_memory_via_mappings (readbuf
, writebuf
, offset
,
838 xfer_status
= this->beneath ()->xfer_partial (object
, annex
, readbuf
,
839 writebuf
, offset
, len
,
841 if (xfer_status
== TARGET_XFER_OK
)
842 return TARGET_XFER_OK
;
844 /* Finally, attempt to access data in core file sections with
845 no contents. These will typically read as all zero. */
846 auto no_contents_cb
= [&] (const struct target_section
*s
)
848 return !has_contents_cb (s
);
850 xfer_status
= section_table_xfer_memory_partial
852 offset
, len
, xfered_len
,
853 m_core_section_table
,
858 case TARGET_OBJECT_AUXV
:
861 /* When the aux vector is stored in core file, BFD
862 represents this with a fake section called ".auxv". */
864 struct bfd_section
*section
;
867 section
= bfd_get_section_by_name (core_bfd
, ".auxv");
869 return TARGET_XFER_E_IO
;
871 size
= bfd_section_size (section
);
873 return TARGET_XFER_EOF
;
879 return TARGET_XFER_EOF
;
880 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
,
881 (file_ptr
) offset
, size
))
883 warning (_("Couldn't read NT_AUXV note in core file."));
884 return TARGET_XFER_E_IO
;
887 *xfered_len
= (ULONGEST
) size
;
888 return TARGET_XFER_OK
;
890 return TARGET_XFER_E_IO
;
892 case TARGET_OBJECT_WCOOKIE
:
895 /* When the StackGhost cookie is stored in core file, BFD
896 represents this with a fake section called
899 struct bfd_section
*section
;
902 section
= bfd_get_section_by_name (core_bfd
, ".wcookie");
904 return TARGET_XFER_E_IO
;
906 size
= bfd_section_size (section
);
908 return TARGET_XFER_EOF
;
914 return TARGET_XFER_EOF
;
915 if (!bfd_get_section_contents (core_bfd
, section
, readbuf
,
916 (file_ptr
) offset
, size
))
918 warning (_("Couldn't read StackGhost cookie in core file."));
919 return TARGET_XFER_E_IO
;
922 *xfered_len
= (ULONGEST
) size
;
923 return TARGET_XFER_OK
;
926 return TARGET_XFER_E_IO
;
928 case TARGET_OBJECT_LIBRARIES
:
929 if (m_core_gdbarch
!= nullptr
930 && gdbarch_core_xfer_shared_libraries_p (m_core_gdbarch
))
933 return TARGET_XFER_E_IO
;
936 *xfered_len
= gdbarch_core_xfer_shared_libraries (m_core_gdbarch
,
940 if (*xfered_len
== 0)
941 return TARGET_XFER_EOF
;
943 return TARGET_XFER_OK
;
946 return TARGET_XFER_E_IO
;
948 case TARGET_OBJECT_LIBRARIES_AIX
:
949 if (m_core_gdbarch
!= nullptr
950 && gdbarch_core_xfer_shared_libraries_aix_p (m_core_gdbarch
))
953 return TARGET_XFER_E_IO
;
957 = gdbarch_core_xfer_shared_libraries_aix (m_core_gdbarch
,
961 if (*xfered_len
== 0)
962 return TARGET_XFER_EOF
;
964 return TARGET_XFER_OK
;
967 return TARGET_XFER_E_IO
;
969 case TARGET_OBJECT_SIGNAL_INFO
:
972 if (m_core_gdbarch
!= nullptr
973 && gdbarch_core_xfer_siginfo_p (m_core_gdbarch
))
975 LONGEST l
= gdbarch_core_xfer_siginfo (m_core_gdbarch
, readbuf
,
982 return TARGET_XFER_EOF
;
984 return TARGET_XFER_OK
;
988 return TARGET_XFER_E_IO
;
991 return this->beneath ()->xfer_partial (object
, annex
, readbuf
,
992 writebuf
, offset
, len
,
999 /* Okay, let's be honest: threads gleaned from a core file aren't
1000 exactly lively, are they? On the other hand, if we don't claim
1001 that each & every one is alive, then we don't get any of them
1002 to appear in an "info thread" command, which is quite a useful
1006 core_target::thread_alive (ptid_t ptid
)
1011 /* Ask the current architecture what it knows about this core file.
1012 That will be used, in turn, to pick a better architecture. This
1013 wrapper could be avoided if targets got a chance to specialize
1016 const struct target_desc
*
1017 core_target::read_description ()
1019 /* If the core file contains a target description note then we will use
1020 that in preference to anything else. */
1021 bfd_size_type tdesc_note_size
= 0;
1022 struct bfd_section
*tdesc_note_section
1023 = bfd_get_section_by_name (core_bfd
, ".gdb-tdesc");
1024 if (tdesc_note_section
!= nullptr)
1025 tdesc_note_size
= bfd_section_size (tdesc_note_section
);
1026 if (tdesc_note_size
> 0)
1028 gdb::char_vector
contents (tdesc_note_size
+ 1);
1029 if (bfd_get_section_contents (core_bfd
, tdesc_note_section
,
1030 contents
.data (), (file_ptr
) 0,
1033 /* Ensure we have a null terminator. */
1034 contents
[tdesc_note_size
] = '\0';
1035 const struct target_desc
*result
1036 = string_read_description_xml (contents
.data ());
1037 if (result
!= nullptr)
1042 if (m_core_gdbarch
&& gdbarch_core_read_description_p (m_core_gdbarch
))
1044 const struct target_desc
*result
;
1046 result
= gdbarch_core_read_description (m_core_gdbarch
, this, core_bfd
);
1051 return this->beneath ()->read_description ();
1055 core_target::pid_to_str (ptid_t ptid
)
1057 struct inferior
*inf
;
1060 /* The preferred way is to have a gdbarch/OS specific
1062 if (m_core_gdbarch
!= nullptr
1063 && gdbarch_core_pid_to_str_p (m_core_gdbarch
))
1064 return gdbarch_core_pid_to_str (m_core_gdbarch
, ptid
);
1066 /* Otherwise, if we don't have one, we'll just fallback to
1067 "process", with normal_pid_to_str. */
1069 /* Try the LWPID field first. */
1072 return normal_pid_to_str (ptid_t (pid
));
1074 /* Otherwise, this isn't a "threaded" core -- use the PID field, but
1075 only if it isn't a fake PID. */
1076 inf
= find_inferior_ptid (this, ptid
);
1077 if (inf
!= NULL
&& !inf
->fake_pid_p
)
1078 return normal_pid_to_str (ptid
);
1080 /* No luck. We simply don't have a valid PID to print. */
1081 return "<main task>";
1085 core_target::thread_name (struct thread_info
*thr
)
1087 if (m_core_gdbarch
!= nullptr
1088 && gdbarch_core_thread_name_p (m_core_gdbarch
))
1089 return gdbarch_core_thread_name (m_core_gdbarch
, thr
);
1094 core_target::has_memory ()
1096 return (core_bfd
!= NULL
);
1100 core_target::has_stack ()
1102 return (core_bfd
!= NULL
);
1106 core_target::has_registers ()
1108 return (core_bfd
!= NULL
);
1111 /* Implement the to_info_proc method. */
1114 core_target::info_proc (const char *args
, enum info_proc_what request
)
1116 struct gdbarch
*gdbarch
= get_current_arch ();
1118 /* Since this is the core file target, call the 'core_info_proc'
1119 method on gdbarch, not 'info_proc'. */
1120 if (gdbarch_core_info_proc_p (gdbarch
))
1121 gdbarch_core_info_proc (gdbarch
, args
, request
);
1126 /* Get a pointer to the current core target. If not connected to a
1127 core target, return NULL. */
1129 static core_target
*
1130 get_current_core_target ()
1132 target_ops
*proc_target
= current_inferior ()->process_target ();
1133 return dynamic_cast<core_target
*> (proc_target
);
1136 /* Display file backed mappings from core file. */
1139 core_target::info_proc_mappings (struct gdbarch
*gdbarch
)
1141 if (!m_core_file_mappings
.empty ())
1143 printf_filtered (_("Mapped address spaces:\n\n"));
1144 if (gdbarch_addr_bit (gdbarch
) == 32)
1146 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1149 " Size", " Offset", "objfile");
1153 printf_filtered (" %18s %18s %10s %10s %s\n",
1156 " Size", " Offset", "objfile");
1160 for (const target_section
&tsp
: m_core_file_mappings
)
1162 ULONGEST start
= tsp
.addr
;
1163 ULONGEST end
= tsp
.endaddr
;
1164 ULONGEST file_ofs
= tsp
.the_bfd_section
->filepos
;
1165 const char *filename
= bfd_get_filename (tsp
.the_bfd_section
->owner
);
1167 if (gdbarch_addr_bit (gdbarch
) == 32)
1168 printf_filtered ("\t%10s %10s %10s %10s %s\n",
1169 paddress (gdbarch
, start
),
1170 paddress (gdbarch
, end
),
1171 hex_string (end
- start
),
1172 hex_string (file_ofs
),
1175 printf_filtered (" %18s %18s %10s %10s %s\n",
1176 paddress (gdbarch
, start
),
1177 paddress (gdbarch
, end
),
1178 hex_string (end
- start
),
1179 hex_string (file_ofs
),
1184 /* Implement "maintenance print core-file-backed-mappings" command.
1186 If mappings are loaded, the results should be similar to the
1187 mappings shown by "info proc mappings". This command is mainly a
1188 debugging tool for GDB developers to make sure that the expected
1189 mappings are present after loading a core file. For Linux, the
1190 output provided by this command will be very similar (if not
1191 identical) to that provided by "info proc mappings". This is not
1192 necessarily the case for other OSes which might provide
1193 more/different information in the "info proc mappings" output. */
1196 maintenance_print_core_file_backed_mappings (const char *args
, int from_tty
)
1198 core_target
*targ
= get_current_core_target ();
1199 if (targ
!= nullptr)
1200 targ
->info_proc_mappings (targ
->core_gdbarch ());
1203 void _initialize_corelow ();
1205 _initialize_corelow ()
1207 add_target (core_target_info
, core_target_open
, filename_completer
);
1208 add_cmd ("core-file-backed-mappings", class_maintenance
,
1209 maintenance_print_core_file_backed_mappings
,
1210 _("Print core file's file-backed mappings."),
1211 &maintenanceprintlist
);