/* Core dump and executable file functions below target vector, for GDB.
- Copyright (C) 1986-2021 Free Software Foundation, Inc.
+ Copyright (C) 1986-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "arch-utils.h"
#include <signal.h>
#include <fcntl.h>
-#include "frame.h" /* required by inferior.h */
+#include "frame.h"
#include "inferior.h"
#include "infrun.h"
#include "symtab.h"
#include "gdbsupport/filestuff.h"
#include "build-id.h"
#include "gdbsupport/pathstuff.h"
+#include "gdbsupport/scoped_fd.h"
+#include "gdbsupport/x86-xstate.h"
+#include "debuginfod-support.h"
#include <unordered_map>
#include <unordered_set>
#include "gdbcmd.h"
#include "xml-tdesc.h"
+#include "memtag.h"
#ifndef O_LARGEFILE
#define O_LARGEFILE 0
bool info_proc (const char *, enum info_proc_what) override;
+ bool supports_memory_tagging () override;
+
+ /* Core file implementation of fetch_memtags. Fetch the memory tags from
+ core file notes. */
+ bool fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type) override;
+
+ x86_xsave_layout fetch_x86_xsave_layout () override;
+
/* A few helpers. */
/* Getter, see variable definition. */
private: /* per-core data */
+ /* Get rid of the core inferior. */
+ void clear_core ();
+
/* The core's section table. Note that these target sections are
*not* mapped in the current address spaces' set of target
sections --- those should come only from pure executable or
shared library bfds. The core bfd sections are an implementation
detail of the core target, just like ptrace is for unix child
targets. */
- target_section_table m_core_section_table;
+ std::vector<target_section> m_core_section_table;
/* File-backed address space mappings: some core files include
information about memory mapped files. */
- target_section_table m_core_file_mappings;
+ std::vector<target_section> m_core_file_mappings;
/* Unavailable mappings. These correspond to pathnames which either
weren't found or could not be opened. Knowing these addresses can
core_target::core_target ()
{
+ /* Find a first arch based on the BFD. We need the initial gdbarch so
+ we can setup the hooks to find a target description. */
m_core_gdbarch = gdbarch_from_bfd (core_bfd);
+ /* If the arch is able to read a target description from the core, it
+ could yield a more specific gdbarch. */
+ const struct target_desc *tdesc = read_description ();
+
+ if (tdesc != nullptr)
+ {
+ struct gdbarch_info info;
+ info.abfd = core_bfd;
+ info.target_desc = tdesc;
+ m_core_gdbarch = gdbarch_find_by_info (info);
+ }
+
if (!m_core_gdbarch
|| !gdbarch_iterate_over_regset_sections_p (m_core_gdbarch))
error (_("\"%s\": Core file format not supported"),
build_file_mappings ();
}
-/* Construct the target_section_table for file-backed mappings if
- they exist.
+/* Construct the table for file-backed mappings if they exist.
For each unique path in the note, we'll open a BFD with a bfd
target of "binary". This is an unstructured bfd target upon which
/* read_core_file_mappings will invoke this lambda for each mapping
that it finds. */
[&] (int num, ULONGEST start, ULONGEST end, ULONGEST file_ofs,
- const char *filename)
+ const char *filename, const bfd_build_id *build_id)
{
/* Architecture-specific read_core_mapping methods are expected to
weed out non-file-backed mappings. */
gdb_assert (filename != nullptr);
+ if (unavailable_paths.find (filename) != unavailable_paths.end ())
+ {
+ /* We have already seen some mapping for FILENAME but failed to
+ find/open the file. There is no point in trying the same
+ thing again so just record that the range [start, end) is
+ unavailable. */
+ m_core_unavailable_mappings.emplace_back (start, end - start);
+ return;
+ }
+
struct bfd *bfd = bfd_map[filename];
if (bfd == nullptr)
{
canonical) pathname will be provided. */
gdb::unique_xmalloc_ptr<char> expanded_fname
= exec_file_find (filename, NULL);
+
+ if (expanded_fname == nullptr && build_id != nullptr)
+ debuginfod_exec_query (build_id->data, build_id->size,
+ filename, &expanded_fname);
+
if (expanded_fname == nullptr)
{
m_core_unavailable_mappings.emplace_back (start, end - start);
- /* Print just one warning per path. */
- if (unavailable_paths.insert (filename).second)
- warning (_("Can't open file %s during file-backed mapping "
- "note processing"),
- filename);
+ unavailable_paths.insert (filename);
+ warning (_("Can't open file %s during file-backed mapping "
+ "note processing"),
+ filename);
return;
}
- bfd = bfd_map[filename] = bfd_openr (expanded_fname.get (),
- "binary");
+ bfd = bfd_openr (expanded_fname.get (), "binary");
if (bfd == nullptr || !bfd_check_format (bfd, bfd_object))
{
m_core_unavailable_mappings.emplace_back (start, end - start);
- /* If we get here, there's a good chance that it's due to
- an internal error. We issue a warning instead of an
- internal error because of the possibility that the
- file was removed in between checking for its
- existence during the expansion in exec_file_find()
- and the calls to bfd_openr() / bfd_check_format().
- Output both the path from the core file note along
- with its expansion to make debugging this problem
- easier. */
+ unavailable_paths.insert (filename);
warning (_("Can't open file %s which was expanded to %s "
"during file-backed mapping note processing"),
filename, expanded_fname.get ());
+
if (bfd != nullptr)
bfd_close (bfd);
return;
This can be checked before/after a core file detach via
"maint info bfds". */
gdb_bfd_record_inclusion (core_bfd, bfd);
+ bfd_map[filename] = bfd;
}
/* Make new BFD section. All sections have the same name,
/* Set target_section fields. */
m_core_file_mappings.emplace_back (start, end, sec);
+
+ /* If this is a bfd of a shared library, record its soname
+ and build id. */
+ if (build_id != nullptr)
+ {
+ gdb::unique_xmalloc_ptr<char> soname
+ = gdb_bfd_read_elf_soname (bfd->filename);
+ if (soname != nullptr)
+ set_cbfd_soname_build_id (current_program_space->cbfd,
+ soname.get (), build_id);
+ }
});
normalize_mem_ranges (&m_core_unavailable_mappings);
/* An arbitrary identifier for the core inferior. */
#define CORELOW_PID 1
-/* Close the core target. */
-
void
-core_target::close ()
+core_target::clear_core ()
{
if (core_bfd)
{
switch_to_no_thread (); /* Avoid confusion from thread
stuff. */
- exit_inferior_silent (current_inferior ());
+ exit_inferior (current_inferior ());
/* Clear out solib state while the bfd is still open. See
comments in clear_solib in solib.c. */
current_program_space->cbfd.reset (nullptr);
}
+}
+
+/* Close the core target. */
+
+void
+core_target::close ()
+{
+ clear_core ();
/* Core targets are heap-allocated (see core_target_open), so here
we delete ourselves. */
/* Look for sections whose names start with `.reg/' so that we can
extract the list of threads in a core file. */
+/* If ASECT is a section whose name begins with '.reg/' then extract the
+ lwpid after the '/' and create a new thread in INF.
+
+ If REG_SECT is not nullptr, and the both ASECT and REG_SECT point at the
+ same position in the parent bfd object then switch to the newly created
+ thread, otherwise, the selected thread is left unchanged. */
+
static void
-add_to_thread_list (asection *asect, asection *reg_sect)
+add_to_thread_list (asection *asect, asection *reg_sect, inferior *inf)
{
- int core_tid;
- int pid, lwpid;
- bool fake_pid_p = false;
- struct inferior *inf;
-
if (!startswith (bfd_section_name (asect), ".reg/"))
return;
- core_tid = atoi (bfd_section_name (asect) + 5);
-
- pid = bfd_core_file_pid (core_bfd);
- if (pid == 0)
- {
- fake_pid_p = true;
- pid = CORELOW_PID;
- }
-
- lwpid = core_tid;
-
- inf = current_inferior ();
- if (inf->pid == 0)
- {
- inferior_appeared (inf, pid);
- inf->fake_pid_p = fake_pid_p;
- }
-
- ptid_t ptid (pid, lwpid);
-
+ int lwpid = atoi (bfd_section_name (asect) + 5);
+ ptid_t ptid (inf->pid, lwpid);
thread_info *thr = add_thread (inf->process_target (), ptid);
-/* Warning, Will Robinson, looking at BFD private data! */
+ /* Warning, Will Robinson, looking at BFD private data! */
if (reg_sect != NULL
&& asect->filepos == reg_sect->filepos) /* Did we find .reg? */
maybe_say_no_core_file_now (int from_tty)
{
if (from_tty)
- printf_filtered (_("No core file now.\n"));
+ gdb_printf (_("No core file now.\n"));
}
/* Backward compatibility with old way of specifying core files. */
core_target_open (filename, from_tty);
}
+/* A vmcore file is a core file created by the Linux kernel at the point of
+ a crash. Each thread in the core file represents a real CPU core, and
+ the lwpid for each thread is the pid of the process that was running on
+ that core at the moment of the crash.
+
+ However, not every CPU core will have been running a process, some cores
+ will be idle. For these idle cores the CPU writes an lwpid of 0. And
+ of course, multiple cores might be idle, so there could be multiple
+ threads with an lwpid of 0.
+
+ The problem is GDB doesn't really like threads with an lwpid of 0; GDB
+ presents such a thread as a process rather than a thread. And GDB
+ certainly doesn't like multiple threads having the same lwpid, each time
+ a new thread is seen with the same lwpid the earlier thread (with the
+ same lwpid) will be deleted.
+
+ This function addresses both of these problems by assigning a fake lwpid
+ to any thread with an lwpid of 0.
+
+ GDB finds the lwpid information by looking at the bfd section names
+ which include the lwpid, e.g. .reg/NN where NN is the lwpid. This
+ function looks though all the section names looking for sections named
+ .reg/NN. If any sections are found where NN == 0, then we assign a new
+ unique value of NN. Then, in a second pass, any sections ending /0 are
+ assigned their new number.
+
+ Remember, a core file may contain multiple register sections for
+ different register sets, but the sets are always grouped by thread, so
+ we can figure out which registers should be assigned the same new
+ lwpid. For example, consider a core file containing:
+
+ .reg/0, .reg2/0, .reg/0, .reg2/0
+
+ This represents two threads, each thread contains a .reg and .reg2
+ register set. The .reg represents the start of each thread. After
+ renaming the sections will now look like this:
+
+ .reg/1, .reg2/1, .reg/2, .reg2/2
+
+ After calling this function the rest of the core file handling code can
+ treat this core file just like any other core file. */
+
+static void
+rename_vmcore_idle_reg_sections (bfd *abfd, inferior *inf)
+{
+ /* Map from the bfd section to its lwpid (the /NN number). */
+ std::vector<std::pair<asection *, int>> sections_and_lwpids;
+
+ /* The set of all /NN numbers found. Needed so we can easily find unused
+ numbers in the case that we need to rename some sections. */
+ std::unordered_set<int> all_lwpids;
+
+ /* A count of how many sections called .reg/0 we have found. */
+ unsigned zero_lwpid_count = 0;
+
+ /* Look for all the .reg sections. Record the section object and the
+ lwpid which is extracted from the section name. Spot if any have an
+ lwpid of zero. */
+ for (asection *sect : gdb_bfd_sections (core_bfd))
+ {
+ if (startswith (bfd_section_name (sect), ".reg/"))
+ {
+ int lwpid = atoi (bfd_section_name (sect) + 5);
+ sections_and_lwpids.emplace_back (sect, lwpid);
+ all_lwpids.insert (lwpid);
+ if (lwpid == 0)
+ zero_lwpid_count++;
+ }
+ }
+
+ /* If every ".reg/NN" section has a non-zero lwpid then we don't need to
+ do any renaming. */
+ if (zero_lwpid_count == 0)
+ return;
+
+ /* Assign a new number to any .reg sections with an lwpid of 0. */
+ int new_lwpid = 1;
+ for (auto §_and_lwpid : sections_and_lwpids)
+ if (sect_and_lwpid.second == 0)
+ {
+ while (all_lwpids.find (new_lwpid) != all_lwpids.end ())
+ new_lwpid++;
+ sect_and_lwpid.second = new_lwpid;
+ new_lwpid++;
+ }
+
+ /* Now update the names of any sections with an lwpid of 0. This is
+ more than just the .reg sections we originally found. */
+ std::string replacement_lwpid_str;
+ auto iter = sections_and_lwpids.begin ();
+ int replacement_lwpid = 0;
+ for (asection *sect : gdb_bfd_sections (core_bfd))
+ {
+ if (iter != sections_and_lwpids.end () && sect == iter->first)
+ {
+ gdb_assert (startswith (bfd_section_name (sect), ".reg/"));
+
+ int lwpid = atoi (bfd_section_name (sect) + 5);
+ if (lwpid == iter->second)
+ {
+ /* This section was not given a new number. */
+ gdb_assert (lwpid != 0);
+ replacement_lwpid = 0;
+ }
+ else
+ {
+ replacement_lwpid = iter->second;
+ ptid_t ptid (inf->pid, replacement_lwpid);
+ if (!replacement_lwpid_str.empty ())
+ replacement_lwpid_str += ", ";
+ replacement_lwpid_str += target_pid_to_str (ptid);
+ }
+
+ iter++;
+ }
+
+ if (replacement_lwpid != 0)
+ {
+ const char *name = bfd_section_name (sect);
+ size_t len = strlen (name);
+
+ if (strncmp (name + len - 2, "/0", 2) == 0)
+ {
+ /* This section needs a new name. */
+ std::string name_str
+ = string_printf ("%.*s/%d",
+ static_cast<int> (len - 2),
+ name, replacement_lwpid);
+ char *name_buf
+ = static_cast<char *> (bfd_alloc (abfd, name_str.size () + 1));
+ if (name_buf == nullptr)
+ error (_("failed to allocate space for section name '%s'"),
+ name_str.c_str ());
+ memcpy (name_buf, name_str.c_str(), name_str.size () + 1);
+ bfd_rename_section (sect, name_buf);
+ }
+ }
+ }
+
+ if (zero_lwpid_count == 1)
+ warning (_("found thread with pid 0, assigned replacement Target Id: %s"),
+ replacement_lwpid_str.c_str ());
+ else
+ warning (_("found threads with pid 0, assigned replacement Target Ids: %s"),
+ replacement_lwpid_str.c_str ());
+}
+
/* Locate (and load) an executable file (and symbols) given the core file
BFD ABFD. */
gdb_bfd_ref_ptr execbfd
= build_id_to_exec_bfd (build_id->size, build_id->data);
+ if (execbfd == nullptr)
+ {
+ /* Attempt to query debuginfod for the executable. */
+ gdb::unique_xmalloc_ptr<char> execpath;
+ scoped_fd fd = debuginfod_exec_query (build_id->data, build_id->size,
+ abfd->filename, &execpath);
+
+ if (fd.get () >= 0)
+ {
+ execbfd = gdb_bfd_open (execpath.get (), gnutarget);
+
+ if (execbfd == nullptr)
+ warning (_("\"%s\" from debuginfod cannot be opened as bfd: %s"),
+ execpath.get (),
+ gdb_bfd_errmsg (bfd_get_error (), nullptr).c_str ());
+ else if (!build_id_verify (execbfd.get (), build_id->size,
+ build_id->data))
+ execbfd.reset (nullptr);
+ }
+ }
+
if (execbfd != nullptr)
{
exec_file_attach (bfd_get_filename (execbfd.get ()), from_tty);
}
gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg));
- if (!IS_ABSOLUTE_PATH (filename.get ()))
- filename = gdb_abspath (filename.get ());
+ if (strlen (filename.get ()) != 0
+ && !IS_ABSOLUTE_PATH (filename.get ()))
+ filename = make_unique_xstrdup (gdb_abspath (filename.get ()).c_str ());
flags = O_BINARY | O_LARGEFILE;
if (write_files)
flags |= O_RDWR;
else
flags |= O_RDONLY;
- scratch_chan = gdb_open_cloexec (filename.get (), flags, 0);
+ scratch_chan = gdb_open_cloexec (filename.get (), flags, 0).release ();
if (scratch_chan < 0)
perror_with_name (filename.get ());
previous session, and the frame cache being stale. */
registers_changed ();
+ /* Find (or fake) the pid for the process in this core file, and
+ initialise the current inferior with that pid. */
+ bool fake_pid_p = false;
+ int pid = bfd_core_file_pid (core_bfd);
+ if (pid == 0)
+ {
+ fake_pid_p = true;
+ pid = CORELOW_PID;
+ }
+
+ inferior *inf = current_inferior ();
+ gdb_assert (inf->pid == 0);
+ inferior_appeared (inf, pid);
+ inf->fake_pid_p = fake_pid_p;
+
+ /* Rename any .reg/0 sections, giving them each a fake lwpid. */
+ rename_vmcore_idle_reg_sections (core_bfd, inf);
+
/* Build up thread list from BFD sections, and possibly set the
current thread to the .reg/NN section matching the .reg
section. */
asection *reg_sect = bfd_get_section_by_name (core_bfd, ".reg");
for (asection *sect : gdb_bfd_sections (core_bfd))
- add_to_thread_list (sect, reg_sect);
+ add_to_thread_list (sect, reg_sect, inf);
if (inferior_ptid == null_ptid)
{
which was the "main" thread. The latter case shouldn't
usually happen, but we're dealing with input here, which can
always be broken in different ways. */
- thread_info *thread = first_thread_of_inferior (current_inferior ());
+ thread_info *thread = first_thread_of_inferior (inf);
if (thread == NULL)
- {
- inferior_appeared (current_inferior (), CORELOW_PID);
- thread = add_thread_silent (target, ptid_t (CORELOW_PID));
- }
+ thread = add_thread_silent (target, ptid_t (CORELOW_PID));
switch_to_thread (thread);
}
p = bfd_core_file_failing_command (core_bfd);
if (p)
- printf_filtered (_("Core was generated by `%s'.\n"), p);
+ gdb_printf (_("Core was generated by `%s'.\n"), p);
/* Clearing any previous state of convenience variables. */
clear_exit_convenience_vars ();
siggy)
: gdb_signal_from_host (siggy));
- printf_filtered (_("Program terminated with signal %s, %s"),
- gdb_signal_to_name (sig), gdb_signal_to_string (sig));
+ gdb_printf (_("Program terminated with signal %s, %s"),
+ gdb_signal_to_name (sig), gdb_signal_to_string (sig));
if (gdbarch_report_signal_info_p (core_gdbarch))
gdbarch_report_signal_info (core_gdbarch, current_uiout, sig);
- printf_filtered (_(".\n"));
+ gdb_printf (_(".\n"));
/* Set the value of the internal variable $_exitsignal,
which holds the signal uncaught by the inferior. */
void
core_target::detach (inferior *inf, int from_tty)
{
- /* Note that 'this' is dangling after this call. unpush_target
- closes the target, and our close implementation deletes
- 'this'. */
+ /* Get rid of the core. Don't rely on core_target::close doing it,
+ because target_detach may be called with core_target's refcount > 1,
+ meaning core_target::close may not be called yet by the
+ unpush_target call below. */
+ clear_core ();
+
+ /* Note that 'this' may be dangling after this call. unpush_target
+ closes the target if the refcount reaches 0, and our close
+ implementation deletes 'this'. */
inf->unpush_target (this);
/* Clear the register cache and the frame cache. */
if (!(m_core_gdbarch != nullptr
&& gdbarch_iterate_over_regset_sections_p (m_core_gdbarch)))
{
- fprintf_filtered (gdb_stderr,
- "Can't fetch registers from this type of core file\n");
+ gdb_printf (gdb_stderr,
+ "Can't fetch registers from this type of core file\n");
return;
}
return TARGET_XFER_OK;
}
}
- /* FALL THROUGH */
+ return TARGET_XFER_E_IO;
case TARGET_OBJECT_LIBRARIES_AIX:
if (m_core_gdbarch != nullptr
return TARGET_XFER_OK;
}
}
- /* FALL THROUGH */
+ return TARGET_XFER_E_IO;
case TARGET_OBJECT_SIGNAL_INFO:
if (readbuf)
const struct target_desc *
core_target::read_description ()
{
- /* If the core file contains a target description note then we will use
- that in preference to anything else. */
- bfd_size_type tdesc_note_size = 0;
- struct bfd_section *tdesc_note_section
- = bfd_get_section_by_name (core_bfd, ".gdb-tdesc");
- if (tdesc_note_section != nullptr)
- tdesc_note_size = bfd_section_size (tdesc_note_section);
- if (tdesc_note_size > 0)
+ /* First check whether the target wants us to use the corefile target
+ description notes. */
+ if (gdbarch_use_target_description_from_corefile_notes (m_core_gdbarch,
+ core_bfd))
{
- gdb::char_vector contents (tdesc_note_size + 1);
- if (bfd_get_section_contents (core_bfd, tdesc_note_section,
- contents.data (), (file_ptr) 0,
- tdesc_note_size))
+ /* If the core file contains a target description note then go ahead and
+ use that. */
+ bfd_size_type tdesc_note_size = 0;
+ struct bfd_section *tdesc_note_section
+ = bfd_get_section_by_name (core_bfd, ".gdb-tdesc");
+ if (tdesc_note_section != nullptr)
+ tdesc_note_size = bfd_section_size (tdesc_note_section);
+ if (tdesc_note_size > 0)
{
- /* Ensure we have a null terminator. */
- contents[tdesc_note_size] = '\0';
- const struct target_desc *result
- = string_read_description_xml (contents.data ());
- if (result != nullptr)
- return result;
+ gdb::char_vector contents (tdesc_note_size + 1);
+ if (bfd_get_section_contents (core_bfd, tdesc_note_section,
+ contents.data (), (file_ptr) 0,
+ tdesc_note_size))
+ {
+ /* Ensure we have a null terminator. */
+ contents[tdesc_note_size] = '\0';
+ const struct target_desc *result
+ = string_read_description_xml (contents.data ());
+ if (result != nullptr)
+ return result;
+ }
}
}
+ /* If the architecture provides a corefile target description hook, use
+ it now. Even if the core file contains a target description in a note
+ section, it is not useful for targets that can potentially have distinct
+ descriptions for each thread. One example is AArch64's SVE/SME
+ extensions that allow per-thread vector length changes, resulting in
+ registers with different sizes. */
if (m_core_gdbarch && gdbarch_core_read_description_p (m_core_gdbarch))
{
const struct target_desc *result;
result = gdbarch_core_read_description (m_core_gdbarch, this, core_bfd);
- if (result != NULL)
+ if (result != nullptr)
return result;
}
return true;
}
+/* Implementation of the "supports_memory_tagging" target_ops method. */
+
+bool
+core_target::supports_memory_tagging ()
+{
+ /* Look for memory tag sections. If they exist, that means this core file
+ supports memory tagging. */
+
+ return (bfd_get_section_by_name (core_bfd, "memtag") != nullptr);
+}
+
+/* Implementation of the "fetch_memtags" target_ops method. */
+
+bool
+core_target::fetch_memtags (CORE_ADDR address, size_t len,
+ gdb::byte_vector &tags, int type)
+{
+ gdbarch *gdbarch = current_inferior ()->arch ();
+
+ /* Make sure we have a way to decode the memory tag notes. */
+ if (!gdbarch_decode_memtag_section_p (gdbarch))
+ error (_("gdbarch_decode_memtag_section not implemented for this "
+ "architecture."));
+
+ memtag_section_info info;
+ info.memtag_section = nullptr;
+
+ while (get_next_core_memtag_section (core_bfd, info.memtag_section,
+ address, info))
+ {
+ size_t adjusted_length
+ = (address + len < info.end_address) ? len : (info.end_address - address);
+
+ /* Decode the memory tag note and return the tags. */
+ gdb::byte_vector tags_read
+ = gdbarch_decode_memtag_section (gdbarch, info.memtag_section, type,
+ address, adjusted_length);
+
+ /* Transfer over the tags that have been read. */
+ tags.insert (tags.end (), tags_read.begin (), tags_read.end ());
+
+ /* ADDRESS + LEN may cross the boundaries of a particular memory tag
+ segment. Check if we need to fetch tags from a different section. */
+ if (!tags_read.empty () && (address + len) < info.end_address)
+ return true;
+
+ /* There are more tags to fetch. Update ADDRESS and LEN. */
+ len -= (info.end_address - address);
+ address = info.end_address;
+ }
+
+ return false;
+}
+
+/* Implementation of the "fetch_x86_xsave_layout" target_ops method. */
+
+x86_xsave_layout
+core_target::fetch_x86_xsave_layout ()
+{
+ if (m_core_gdbarch != nullptr &&
+ gdbarch_core_read_x86_xsave_layout_p (m_core_gdbarch))
+ {
+ x86_xsave_layout layout;
+ if (!gdbarch_core_read_x86_xsave_layout (m_core_gdbarch, layout))
+ return {};
+
+ return layout;
+ }
+
+ return {};
+}
+
/* Get a pointer to the current core target. If not connected to a
core target, return NULL. */
{
if (!m_core_file_mappings.empty ())
{
- printf_filtered (_("Mapped address spaces:\n\n"));
+ gdb_printf (_("Mapped address spaces:\n\n"));
if (gdbarch_addr_bit (gdbarch) == 32)
{
- printf_filtered ("\t%10s %10s %10s %10s %s\n",
- "Start Addr",
- " End Addr",
- " Size", " Offset", "objfile");
+ gdb_printf ("\t%10s %10s %10s %10s %s\n",
+ "Start Addr",
+ " End Addr",
+ " Size", " Offset", "objfile");
}
else
{
- printf_filtered (" %18s %18s %10s %10s %s\n",
- "Start Addr",
- " End Addr",
- " Size", " Offset", "objfile");
+ gdb_printf (" %18s %18s %10s %10s %s\n",
+ "Start Addr",
+ " End Addr",
+ " Size", " Offset", "objfile");
}
}
const char *filename = bfd_get_filename (tsp.the_bfd_section->owner);
if (gdbarch_addr_bit (gdbarch) == 32)
- printf_filtered ("\t%10s %10s %10s %10s %s\n",
- paddress (gdbarch, start),
- paddress (gdbarch, end),
- hex_string (end - start),
- hex_string (file_ofs),
- filename);
+ gdb_printf ("\t%10s %10s %10s %10s %s\n",
+ paddress (gdbarch, start),
+ paddress (gdbarch, end),
+ hex_string (end - start),
+ hex_string (file_ofs),
+ filename);
else
- printf_filtered (" %18s %18s %10s %10s %s\n",
- paddress (gdbarch, start),
- paddress (gdbarch, end),
- hex_string (end - start),
- hex_string (file_ofs),
- filename);
+ gdb_printf (" %18s %18s %10s %10s %s\n",
+ paddress (gdbarch, start),
+ paddress (gdbarch, end),
+ hex_string (end - start),
+ hex_string (file_ofs),
+ filename);
}
}
projects / binutils-gdb.git / blobdiff